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

ResLengthThree -- Computation of multiplicative structures on free resolutions of length three
**********************************************************************************************

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

Let I  be a homogeneous ideal contained in the irrelevant maximal ideal of a
graded ring Q  (obtained as a quotient of a polynomial ring). If the length of
the minimal free resolution F  of  $R=Q/I$  is 3, then the resolution admits
the structure of a differential graded algebra. The induced algebra structure
on  $A = Tor^Q(R,k)$  is unique and provides for a classification of such
quotient rings.  The package determines a multiplicative structure on the free
resolution F  as well as the unique induced structure on A and the class of the
quotient R according to the classification scheme of Avramov, Kustin, and
Miller (see https://doi.org/10.1016/0021-8693(88)90056-7 ).

Authors
=======

  * Lars Winther Christensen (see http://www.math.ttu.edu/~lchriste/index.html
    ) <lars.w.christensen@ttu.edu>
  * Luigi Ferraro (see http://www.math.ttu.edu/~lferraro ) <lferraro@ttu.edu>
  * Francesca Gandini (see https://github.com/fragandi )
    <fra.gandi.phd@gmail.com>
  * Frank Moore (see http://users.wfu.edu/moorewf/ ) <moorewf@wfu.edu>
  * Oana Veliche (see https://web.northeastern.edu/oveliche/index.html )
    <o.veliche@northeastern.edu>

Version
=======

This documentation describes version 1.0 of ResLengthThree, released 3 December
2020.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{ResLengthThreeSource,                                                  |
|  title = {{ResLengthThree: Multiplication in free resolutions of length thre|
|  author = {Lars Winther Christensen and Luigi Ferraro and Francesca Gandini |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|e. Version~1.0}},                                                            |
|and Frank Moore and Oana Veliche},                                           |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * makeRes -- creates a resolution starting from three
        matrices
      * multTableOneOne -- the multiplication table for
        products of elements in degree one
      * multTableOneTwo -- the multiplication table for
        products of elements in degree one with elements in degree two
      * resLengthThreeAlg -- the minimal free
        resolution presented as a graded-commutative ring
      * resLengthThreeTorAlg -- the Tor algebra
        presented as a graded-commutative ring
      * resLengthThreeTorAlgClass -- the
        class (w.r.t. multiplication in homology) of an ideal
  * Methods
      * "multTableOneOne(Ring)" -- see multTableOneOne,
        -- the multiplication table for products of elements in degree one
      * "multTableOneTwo(Ring)" -- see multTableOneTwo,
        -- the multiplication table for products of elements in degree one with
        elements in degree two
      * "resLengthThreeAlg(Complex)" -- see resLengthThreeAlg,
        -- the minimal free resolution presented as a
        graded-commutative ring
      * "resLengthThreeAlg(Complex,List)" -- see resLengthThreeAlg,
        -- the minimal free resolution presented as a
        graded-commutative ring
      * "resLengthThreeTorAlg(Complex)" -- see resLengthThreeTorAlg,
        -- the Tor algebra presented as a
        graded-commutative ring
      * "resLengthThreeTorAlg(Complex,List)" -- see resLengthThreeTorAlg,
        -- the Tor algebra presented as a
        graded-commutative ring
      * "resLengthThreeTorAlgClass(Complex)" -- see
        resLengthThreeTorAlgClass, -- the class
        (w.r.t. multiplication in homology) of an ideal
      * "resLengthThreeTorAlgClass(Ideal)" -- see
        resLengthThreeTorAlgClass, -- the class
        (w.r.t. multiplication in homology) of an ideal
  * Symbols
      * Labels -- an optional argument for multTableOneOne and
        MultTableOneTwo determining whether to label rows and columns
      * "Compact" -- see multTableOneOne(...,Compact=>...),
        -- an optional
        argument for multTableOneOne that prints dots below the diagonal

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

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

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

The source of this document is in ResLengthThree.m2:424:0.

Labels -- an optional argument for multTableOneOne and MultTableOneTwo determining whether to label rows and columns
********************************************************************************************************************

  * Usage:
        multTableOneOne A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table, use netList (Macaulay2Doc), to display it as a
        table

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

multTableOneTwo A

The default value of Labels, is true (Macaulay2Doc).
Changing the value to false (Macaulay2Doc), removes the row and
column labels.

+-------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                          |
+-------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)|
|                                                             |
|o2 = A                                                       |
|                                                             |
|o2 : QuotientRing                                            |
+-------------------------------------------------------------+
|i3 : netList multTableOneOne (A, Labels => false)            |
|                                                             |
|     +---+---+--+                                            |
|o3 = |0  |f  |f |                                            |
|     |   | 1 | 2|                                            |
|     +---+---+--+                                            |
|     |-f |0  |f |                                            |
|     |  1|   | 3|                                            |
|     +---+---+--+                                            |
|     |-f |-f |0 |                                            |
|     |  2|  3|  |                                            |
|     +---+---+--+                                            |
+-------------------------------------------------------------+
|i4 : netList multTableOneTwo (A, Labels => false)            |
|                                                             |
|     +--+---+--+                                             |
|o4 = |0 |0  |g |                                             |
|     |  |   | 1|                                             |
|     +--+---+--+                                             |
|     |0 |-g |0 |                                             |
|     |  |  1|  |                                             |
|     +--+---+--+                                             |
|     |g |0  |0 |                                             |
|     | 1|   |  |                                             |
|     +--+---+--+                                             |
+-------------------------------------------------------------+

Functions with optional argument named Labels:
==============================================

  * multTableOneOne(...,Labels=>...)
    -- an optional argument
    for multTableOneOne determining whether to label rows and columns
  * multTableOneTwo(...,Labels=>...)
    -- an optional argument
    for multTableOneTwo determining whether to label rows and columns

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

The object Labels, is a symbol (Macaulay2Doc).

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

The source of this document is in ResLengthThree.m2:689:0.

makeRes -- creates a resolution starting from three matrices
************************************************************

  * Usage:
        makeRes(d1,d2,d3)
  * Inputs:
      * d1, a matrix (Macaulay2Doc), of the differential in
        degree 1
      * d2, a matrix (Macaulay2Doc), of the differential in
        degree 2
      * d3, a matrix (Macaulay2Doc), of the differential in
        degree 3
  * Outputs:
      * a complex (Complexes), the resolution with differentials
        d1, d2, d3.

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

Creates a resolution of length 3 that has the given three matrices as
differentials.

+-----------------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                          |
+-----------------------------------------------------------------------------+
|i2 : d1=matrix{{-x^2,z^2-x*y,-y^2,-x*z,-y*z}}                                |
|                                                                             |
|o2 = | -x2 -xy+z2 -y2 -xz -yz |                                              |
|                                                                             |
|             1      5                                                        |
|o2 : Matrix Q  <-- Q                                                         |
+-----------------------------------------------------------------------------+
|i3 : d2=matrix{{0,0,z,0,-y},{0,0,0,-y,x},{-z,0,0,x,0},{0,y,-x,0,z},{y,-x,0,-z|
|                                                                             |
|o3 = | 0  0  z  0  -y |                                                      |
|     | 0  0  0  -y x  |                                                      |
|     | -z 0  0  x  0  |                                                      |
|     | 0  y  -x 0  z  |                                                      |
|     | y  -x 0  -z 0  |                                                      |
|                                                                             |
|             5      5                                                        |
|o3 : Matrix Q  <-- Q                                                         |
|-----------------------------------------------------------------------------|
|,0}}                                                                         |
+-----------------------------------------------------------------------------+
|i4 : d3=transpose d1                                                         |
|                                                                             |
|o4 = {-2} | -x2    |                                                         |
|     {-2} | -xy+z2 |                                                         |
|     {-2} | -y2    |                                                         |
|     {-2} | -xz    |                                                         |
|     {-2} | -yz    |                                                         |
|                                                                             |
|             5      1                                                        |
|o4 : Matrix Q  <-- Q                                                         |
+-----------------------------------------------------------------------------+
|i5 : makeRes(d1,d2,d3)                                                       |
|                                                                             |
|      1      5      5      1                                                 |
|o5 = Q  <-- Q  <-- Q  <-- Q                                                  |
|                                                                             |
|     0      1      2      3                                                  |
|                                                                             |
|o5 : Complex                                                                 |
+-----------------------------------------------------------------------------+

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

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

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

The source of this document is in ResLengthThree.m2:782:0.

multTableOneOne -- the multiplication table for products of elements in degree one
**********************************************************************************

  * Usage:
        multTableOneOne A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Optional inputs (Macaulay2Doc),:
      * Compact, =>
        ..., default value false, an optional argument for multTableOneOne that
        prints dots below the diagonal
      * Labels, =>
        ..., default value true, an optional argument for multTableOneOne
        determining whether to label rows and columns
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table; use netList (Macaulay2Doc), to display it as a
        table

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

For a free resolution of length three described as a graded-commutative ring A,
the function returns a list of the rows of the multiplication table of elements
in degree one. It also computes the multiplication table for products of
elements in degree one in the graded-commutative homology algebra obtained from
A.

+----------------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                         |
+----------------------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)               |
|                                                                            |
|o2 = A                                                                      |
|                                                                            |
|o2 : QuotientRing                                                           |
+----------------------------------------------------------------------------+
|i3 : multTableOneOne A                                                      |
|                                                                            |
|o3 = {{ , e , e , e }, {e , 0, f , f }, {e , -f , 0, f }, {e , -f , -f , 0}}|
|           1   2   3     1      1   2     2    1      3     3    2    3     |
|                                                                            |
|o3 : List                                                                   |
+----------------------------------------------------------------------------+
|i4 : netList multTableOneOne A                                              |
|                                                                            |
|     +--+---+---+--+                                                        |
|o4 = |  |e  |e  |e |                                                        |
|     |  | 1 | 2 | 3|                                                        |
|     +--+---+---+--+                                                        |
|     |e |0  |f  |f |                                                        |
|     | 1|   | 1 | 2|                                                        |
|     +--+---+---+--+                                                        |
|     |e |-f |0  |f |                                                        |
|     | 2|  1|   | 3|                                                        |
|     +--+---+---+--+                                                        |
|     |e |-f |-f |0 |                                                        |
|     | 3|  2|  3|  |                                                        |
|     +--+---+---+--+                                                        |
+----------------------------------------------------------------------------+

Ways to use multTableOneOne:
============================

  * "multTableOneOne(Ring)"

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

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

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

The source of this document is in ResLengthThree.m2:576:0.

multTableOneOne(...,Compact=>...) -- an optional argument for multTableOneOne that prints dots below the diagonal
*****************************************************************************************************************

  * Usage:
        multTableOneOne A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table; use netList (Macaulay2Doc), to display it as a
        table

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

The default value of Compact,
is false (Macaulay2Doc).
Changing the value to true (Macaulay2Doc),
saves space by printing dots for the products  $e_ie_j$  for  $i>j$

+----------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                   |
+----------------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)         |
|                                                                      |
|o2 = A                                                                |
|                                                                      |
|o2 : QuotientRing                                                     |
+----------------------------------------------------------------------+
|i3 : multTableOneOne (A, Compact => true)                             |
|                                                                      |
|o3 = {{ , e , e , e }, {e , 0, f , f }, {e , ., 0, f }, {e , ., ., 0}}|
|           1   2   3     1      1   2     2         3     3           |
|                                                                      |
|o3 : List                                                             |
+----------------------------------------------------------------------+
|i4 : netList multTableOneOne(A, Compact => true)                      |
|                                                                      |
|     +--+--+--+--+                                                    |
|o4 = |  |e |e |e |                                                    |
|     |  | 1| 2| 3|                                                    |
|     +--+--+--+--+                                                    |
|     |e |0 |f |f |                                                    |
|     | 1|  | 1| 2|                                                    |
|     +--+--+--+--+                                                    |
|     |e |. |0 |f |                                                    |
|     | 2|  |  | 3|                                                    |
|     +--+--+--+--+                                                    |
|     |e |. |. |0 |                                                    |
|     | 3|  |  |  |                                                    |
|     +--+--+--+--+                                                    |
+----------------------------------------------------------------------+

Functions with optional argument named Compact:
===============================================

  * multTableOneOne(...,Compact=>...)
    -- an optional
    argument for multTableOneOne that prints dots below the diagonal

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

  * Default value: false (Macaulay2Doc),
  * Function: multTableOneOne, -- the multiplication
    table for products of elements in degree one
  * Option key: Compact,
    -- an optional
    argument for multTableOneOne that prints dots below the diagonal
-------------------------------------------------------------------------------

The source of this document is in ResLengthThree.m2:629:0.

multTableOneOne(...,Labels=>...) -- an optional argument for multTableOneOne determining whether to label rows and columns
**************************************************************************************************************************

  * Usage:
        multTableOneOne A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table; use netList (Macaulay2Doc), to display it as a
        table

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

The default value of Labels, is true (Macaulay2Doc).
Changing the value to false (Macaulay2Doc), removes the row and
column labels.

+-------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                          |
+-------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)|
|                                                             |
|o2 = A                                                       |
|                                                             |
|o2 : QuotientRing                                            |
+-------------------------------------------------------------+
|i3 : netList multTableOneOne (A, Labels => false)            |
|                                                             |
|     +---+---+--+                                            |
|o3 = |0  |f  |f |                                            |
|     |   | 1 | 2|                                            |
|     +---+---+--+                                            |
|     |-f |0  |f |                                            |
|     |  1|   | 3|                                            |
|     +---+---+--+                                            |
|     |-f |-f |0 |                                            |
|     |  2|  3|  |                                            |
|     +---+---+--+                                            |
+-------------------------------------------------------------+

Functions with optional argument named Labels:
==============================================

  * multTableOneOne(...,Labels=>...)
    -- an optional argument
    for multTableOneOne determining whether to label rows and columns
  * multTableOneTwo(...,Labels=>...)
    -- an optional argument
    for multTableOneTwo determining whether to label rows and columns

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

  * Default value: true (Macaulay2Doc),
  * Function: multTableOneOne, -- the multiplication
    table for products of elements in degree one
  * Option key: Labels, -- an optional argument for
    multTableOneOne and MultTableOneTwo determining whether to label rows and
    columns
-------------------------------------------------------------------------------

The source of this document is in ResLengthThree.m2:602:0.

multTableOneTwo -- the multiplication table for products of elements in degree one with elements in degree two
**************************************************************************************************************

  * Usage:
        multTableOneTwo A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Optional inputs (Macaulay2Doc),:
      * Labels, =>
        ..., default value true, an optional argument for multTableOneTwo
        determining whether to label rows and columns
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table; use netList (Macaulay2Doc), to display it as a
        table

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

For a free resolution of length three described as a graded-commutative ring A,
the function returns a list of the rows of the multiplication table of elements
in degree one with elements in degree two. It also computes the multiplication
table for products of elements in degree one with elements in degree two in the
graded-commutative homology algebra obtained from A.

+-----------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                    |
+-----------------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)          |
|                                                                       |
|o2 = A                                                                 |
|                                                                       |
|o2 : QuotientRing                                                      |
+-----------------------------------------------------------------------+
|i3 : multTableOneTwo A                                                 |
|                                                                       |
|o3 = {{0, f , f , f }, {e , 0, 0, g }, {e , 0, -g , 0}, {e , g , 0, 0}}|
|           1   2   3     1         1     2       1        3   1        |
|                                                                       |
|o3 : List                                                              |
+-----------------------------------------------------------------------+
|i4 : netList multTableOneTwo A                                         |
|                                                                       |
|     +--+--+---+--+                                                    |
|o4 = |0 |f |f  |f |                                                    |
|     |  | 1| 2 | 3|                                                    |
|     +--+--+---+--+                                                    |
|     |e |0 |0  |g |                                                    |
|     | 1|  |   | 1|                                                    |
|     +--+--+---+--+                                                    |
|     |e |0 |-g |0 |                                                    |
|     | 2|  |  1|  |                                                    |
|     +--+--+---+--+                                                    |
|     |e |g |0  |0 |                                                    |
|     | 3| 1|   |  |                                                    |
|     +--+--+---+--+                                                    |
+-----------------------------------------------------------------------+

Ways to use multTableOneTwo:
============================

  * "multTableOneTwo(Ring)"

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

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

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

The source of this document is in ResLengthThree.m2:662:0.

multTableOneTwo(...,Labels=>...) -- an optional argument for multTableOneTwo determining whether to label rows and columns
**************************************************************************************************************************

  * Usage:
        multTableOneTwo A
  * Inputs:
      * A, a ring (Macaulay2Doc), created with
        resLengthThreeAlg, or resLengthThreeTorAlg,
  * Outputs:
      * a list (Macaulay2Doc), of the rows in the multiplication
        table. Use netList (Macaulay2Doc), to display it as a
        table

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

The default value of Labels, is true (Macaulay2Doc).
Changing the value to false (Macaulay2Doc), removes the row and
column labels.

+-------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                          |
+-------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)|
|                                                             |
|o2 = A                                                       |
|                                                             |
|o2 : QuotientRing                                            |
+-------------------------------------------------------------+
|i3 : netList multTableOneTwo (A, Labels => false)            |
|                                                             |
|     +--+---+--+                                             |
|o3 = |0 |0  |g |                                             |
|     |  |   | 1|                                             |
|     +--+---+--+                                             |
|     |0 |-g |0 |                                             |
|     |  |  1|  |                                             |
|     +--+---+--+                                             |
|     |g |0  |0 |                                             |
|     | 1|   |  |                                             |
|     +--+---+--+                                             |
+-------------------------------------------------------------+

Functions with optional argument named Labels:
==============================================

  * multTableOneOne(...,Labels=>...)
    -- an optional argument
    for multTableOneOne determining whether to label rows and columns
  * multTableOneTwo(...,Labels=>...)
    -- an optional argument
    for multTableOneTwo determining whether to label rows and columns

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

  * Default value: true (Macaulay2Doc),
  * Function: multTableOneTwo, -- the multiplication
    table for products of elements in degree one with elements in degree two
  * Option key: Labels, -- an optional argument for
    multTableOneOne and MultTableOneTwo determining whether to label rows and
    columns
-------------------------------------------------------------------------------

The source of this document is in ResLengthThree.m2:715:0.

resLengthThreeAlg -- the minimal free resolution presented as a graded-commutative ring
***************************************************************************************

  * Usage:
        resLengthThreeAlg F, resLengthThreeAlg(F,L)
  * Inputs:
      * F, a complex (Complexes), a length three free resolution
        of a cyclic module
      * L, a list (Macaulay2Doc), of three symbols
  * Outputs:
      * a quotient ring (Macaulay2Doc), the resolution
        presented as a quotient of a graded-commutative free algebra over the
        ambient ring

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

For a free resolution F over a ring Q, the function returns the resolution F as
a quotient of a graded-commutative free algebra over Q. The basis vectors in
degrees 1, 2, and 3 are named with the symbols from the list L. The default
symbols are e, f, and g.

+-------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                          |
+-------------------------------------------------------------+
|i2 : A = resLengthThreeAlg freeResolution ideal (x^2,y^2,z^2)|
|                                                             |
|o2 = A                                                       |
|                                                             |
|o2 : QuotientRing                                            |
+-------------------------------------------------------------+
|i3 : describe A                                              |
|                                                             |
|                     Q[e ..f , g ]                           |
|                        1   3   1                            |
|o3 = --------------------------------------------            |
|     (e e  - f , e e  - f , e e  - f , e f  - g )            |
|       2 3    3   1 3    2   1 2    1   1 3    1             |
+-------------------------------------------------------------+
|i4 : e_1*e_2                                                 |
|                                                             |
|o4 = f                                                       |
|      1                                                      |
|                                                             |
|o4 : A                                                       |
+-------------------------------------------------------------+
|i5 : e_1*f_2                                                 |
|                                                             |
|o5 = 0                                                       |
|                                                             |
|o5 : A                                                       |
+-------------------------------------------------------------+
|i6 : e_1*f_3                                                 |
|                                                             |
|o6 = g                                                       |
|      1                                                      |
|                                                             |
|o6 : A                                                       |
+-------------------------------------------------------------+
|i7 : f_1*f_2                                                 |
|                                                             |
|o7 = 0                                                       |
|                                                             |
|o7 : A                                                       |
+-------------------------------------------------------------+

The ambient ring Q does not need to be a polynomial algebra.

+-----------------------------------------------------------------------------+
|i8 : P = QQ[u,v,x,y,z];                                                      |
+-----------------------------------------------------------------------------+
|i9 : Q = P/ideal(u^2,u*v);                                                   |
+-----------------------------------------------------------------------------+
|i10 : F = resLengthThreeAlg(freeResolution(ideal (x^2,x*y,y^2,z^2),          |
|                                                                             |
|o10 = F                                                                      |
|                                                                             |
|o10 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|LengthLimit => 3), {a,b,c} )                                                 |
+-----------------------------------------------------------------------------+
|i11 : describe F                                                             |
|                                                                             |
|                                                                     Q[a ..a |
|                                                                        1   4|
|o11 = -----------------------------------------------------------------------|
|                                                                             |
|      (a a  - b , a a  - b , a a  - b , a a  - y*b , a a  - x*b  - y*b , a a |
|        3 4    3   2 4    4   1 4    5   2 3      1   1 3      1      2   1 2|
|-----------------------------------------------------------------------------|
|, b ..b , c ..c ]                                                            |
|   1   5   1   2                                                             |
|-----------------------------------------------------------------------------|
|                                                                    2        |
| - x*b , a b  + c , a b , a b , a b , a b  + c , a b , a b , a b , b , b b , |
|      2   4 2    2   3 2   2 2   1 2   4 1    1   3 1   2 1   1 1   2   1 2  |
|-----------------------------------------------------------------------------|
|---                                                                          |
| 2                                                                           |
|b )                                                                          |
| 1                                                                           |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|i12 : P = QQ[u,v];                                                           |
+-----------------------------------------------------------------------------+
|i13 : Q = (P/ideal(u^2,u*v))[x,y,z];                                         |
+-----------------------------------------------------------------------------+
|i14 : A = resLengthThreeAlg freeResolution(ideal (x^2,x*y,y^2,z^2),          |
|                                                                             |
|o14 = A                                                                      |
|                                                                             |
|o14 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|LengthLimit => 3)                                                            |
+-----------------------------------------------------------------------------+
|i15 : describe A                                                             |
|                                                                             |
|                                                                     Q[e ..e |
|                                                                        1   4|
|o15 = -----------------------------------------------------------------------|
|                                                                             |
|      (e e  - f , e e  - f , e e  - f , e e  - y*f , e e  - y*f  - x*f , e e |
|        3 4    5   2 4    4   1 4    3   2 3      2   1 3      1      2   1 2|
|-----------------------------------------------------------------------------|
|, f ..f , g ..g ]                                                            |
|   1   5   1   2                                                             |
|-----------------------------------------------------------------------------|
|                                                                    2        |
| - x*f , e f  - g , e f , e f , e f , e f  - g , e f , e f , e f , f , f f , |
|      1   4 2    2   3 2   2 2   1 2   4 1    1   3 1   2 1   1 1   2   1 2  |
|-----------------------------------------------------------------------------|
|---                                                                          |
| 2                                                                           |
|f )                                                                          |
| 1                                                                           |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|i16 : P = ZZ[x,y,z];                                                         |
+-----------------------------------------------------------------------------+
|i17 : Q = P/ideal(4_P);                                                      |
+-----------------------------------------------------------------------------+
|i18 : A = resLengthThreeAlg freeResolution(ideal (x^2,y^2,z^2), LengthLimit  |
|                                                                             |
|o18 = A                                                                      |
|                                                                             |
|o18 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|=> 4)                                                                        |
+-----------------------------------------------------------------------------+
|i19 : describe A                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|o19 = -----------------------------------------------------------------------|
|                                                                             |
|      (e e  - f , e e  - f , e e  - f , e f , e f  - g , e f , e f , e f , e |
|        2 3    2   1 3    3   1 2    1   3 3   2 3    1   1 3   3 2   2 2   1|
|-----------------------------------------------------------------------------|
|       Q[e ..f , g ]                                                         |
|          1   3   1                                                          |
|-----------------------------------------------------------------------------|
|                                                   2               2         |
|f  + g , e f  + g , e f , e f , e g , e g , e g , f , f f , f f , f , f f , f|
| 2    1   3 1    1   2 1   1 1   3 1   2 1   1 1   3   2 3   1 3   2   1 2   |
|-----------------------------------------------------------------------------|
|--------------------                                                         |
|2                                                                            |
| , f g , f g , f g )                                                         |
|1   3 1   2 1   1 1                                                          |
+-----------------------------------------------------------------------------+

Caveat
======

The ambient ring Q must be homogeneous.

Ways to use resLengthThreeAlg:
==============================

  * "resLengthThreeAlg(Complex)"
  * "resLengthThreeAlg(Complex,List)"

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

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

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

The source of this document is in ResLengthThree.m2:487:0.

resLengthThreeTorAlg -- the Tor algebra presented as a graded-commutative ring
******************************************************************************

  * Usage:
        resLengthThreeTorAlg F, resLengthThreeTorAlg(F,L)
  * Inputs:
      * F, a complex (Complexes), a length three free resolution
        of a cyclic module
      * L, a list (Macaulay2Doc), of three symbols
  * Outputs:
      * a quotient ring (Macaulay2Doc), the Tor algebra
        presented as a quotient of a graded-commutative free algebra over the
        residue field of the ambient ring

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

For a free resolution F over a ring Q, the function returns the algebra
$Tor^Q(R,k)$  as a quotient of a graded-commutative free algebra over the
residue field of Q. The basis vectors in degrees 1, 2, and 3 are named with the
symbols from the list L. The default symbols are e, f, and g.

+----------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                             |
+----------------------------------------------------------------+
|i2 : A = resLengthThreeTorAlg freeResolution ideal (x^2,y^2,z^2)|
|                                                                |
|o2 = A                                                          |
|                                                                |
|o2 : QuotientRing                                               |
+----------------------------------------------------------------+
|i3 : describe A                                                 |
|                                                                |
|                    QQ[e ..f , g ]                              |
|                        1   3   1                               |
|o3 = --------------------------------------------               |
|     (e e  - f , e e  - f , e e  - f , e f  - g )               |
|       2 3    3   1 3    2   1 2    1   1 3    1                |
+----------------------------------------------------------------+
|i4 : e_1*e_2                                                    |
|                                                                |
|o4 = f                                                          |
|      1                                                         |
|                                                                |
|o4 : A                                                          |
+----------------------------------------------------------------+
|i5 : e_1*f_2                                                    |
|                                                                |
|o5 = 0                                                          |
|                                                                |
|o5 : A                                                          |
+----------------------------------------------------------------+
|i6 : e_1*f_3                                                    |
|                                                                |
|o6 = g                                                          |
|      1                                                         |
|                                                                |
|o6 : A                                                          |
+----------------------------------------------------------------+
|i7 : f_1*f_2                                                    |
|                                                                |
|o7 = 0                                                          |
|                                                                |
|o7 : A                                                          |
+----------------------------------------------------------------+

The ambient ring Q does not need to be a polynomial algebra.

+-----------------------------------------------------------------------------+
|i8 : P = QQ[u,v,x,y,z];                                                      |
+-----------------------------------------------------------------------------+
|i9 : Q = P/ideal(u^2,u*v);                                                   |
+-----------------------------------------------------------------------------+
|i10 : A = resLengthThreeTorAlg (freeResolution(ideal (x^2,x*y,y^2,z^2),      |
|                                                                             |
|o10 = A                                                                      |
|                                                                             |
|o10 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|LengthLimit => 4), {a,b,c} )                                                 |
+-----------------------------------------------------------------------------+
|i11 : describe A                                                             |
|                                                                             |
|                                                       QQ[a ..a , b ..b , c .|
|                                                           1   4   1   5   1 |
|o11 = -----------------------------------------------------------------------|
|                                                                             |
|      (a a  - b , a a  - b , a a  - b , a a , a a , a a , a b  + c , a b , a |
|        3 4    3   2 4    4   1 4    5   2 3   1 3   1 2   4 2    2   3 2   2|
|-----------------------------------------------------------------------------|
|.c ]                                                                         |
|  2                                                                          |
|----------------------------------------------------                         |
|                                        2         2                          |
|b , a b , a b  + c , a b , a b , a b , b , b b , b )                         |
| 2   1 2   4 1    1   3 1   2 1   1 1   2   1 2   1                          |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|i12 : P = QQ[u,v];                                                           |
+-----------------------------------------------------------------------------+
|i13 : Q = (P/ideal(u^2,u*v))[x,y,z];                                         |
+-----------------------------------------------------------------------------+
|i14 : A = resLengthThreeTorAlg ( freeResolution(ideal (x^2,x*y,y^2,z^2),     |
|                                                                             |
|o14 = A                                                                      |
|                                                                             |
|o14 : QuotientRing                                                           |
|-----------------------------------------------------------------------------|
|LengthLimit => 4), {a,b,c} )                                                 |
+-----------------------------------------------------------------------------+
|i15 : describe A                                                             |
|                                                                             |
|                                                       QQ[a ..a , b ..b , c .|
|                                                           1   4   1   5   1 |
|o15 = -----------------------------------------------------------------------|
|                                                                             |
|      (a a  - b , a a  - b , a a  - b , a a , a a , a a , a b  - c , a b , a |
|        3 4    5   2 4    4   1 4    3   2 3   1 3   1 2   4 2    2   3 2   2|
|-----------------------------------------------------------------------------|
|.c ]                                                                         |
|  2                                                                          |
|----------------------------------------------------                         |
|                                        2         2                          |
|b , a b , a b  - c , a b , a b , a b , b , b b , b )                         |
| 2   1 2   4 1    1   3 1   2 1   1 1   2   1 2   1                          |
+-----------------------------------------------------------------------------+

Caveat
======

For the function to return an algebra over the residue field of the ambient
ring Q that ring must a homogeneous quotient of a polynomial algebra over a
field.

Ways to use resLengthThreeTorAlg:
=================================

  * "resLengthThreeTorAlg(Complex)"
  * "resLengthThreeTorAlg(Complex,List)"

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

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

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

The source of this document is in ResLengthThree.m2:544:0.

resLengthThreeTorAlgClass -- the class (w.r.t. multiplication in homology) of an ideal
**************************************************************************************

  * Usage:
        resLengthThreeTorAlgClass F
  * Inputs:
      * F, a complex (Complexes), a length three free resolution
        of a cyclic module
      * I, an ideal (Macaulay2Doc), an ideal of codepth 3
  * Outputs:
      * a string (Macaulay2Doc), the (parametrized) class of the
        ideal I

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

Classifies the ideal   $I$   as belonging to one of the (parametrized) classes
B ,  C(c),  G(r), H(p,q) , T, provided that it is codepth 3.

+-----------------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                          |
+-----------------------------------------------------------------------------+
|i2 : resLengthThreeTorAlgClass ideal (x*y,x^2,y*z,z^2)                       |
|                                                                             |
|o2 = B                                                                       |
+-----------------------------------------------------------------------------+
|i3 : resLengthThreeTorAlgClass ideal (x^2,y^2,z^2)                           |
|                                                                             |
|o3 = C(3)                                                                    |
+-----------------------------------------------------------------------------+
|i4 : resLengthThreeTorAlgClass ideal (x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3)       |
|                                                                             |
|o4 = G(3)                                                                    |
+-----------------------------------------------------------------------------+
|i5 : resLengthThreeTorAlgClass ideal                                         |
|                                                                             |
|o5 = G(5)                                                                    |
|-----------------------------------------------------------------------------|
|(x*z+y*z,x*y+y*z,x^2-y*z,y*z^2+z^3,y^3-z^3)                                  |
+-----------------------------------------------------------------------------+
|i6 : resLengthThreeTorAlgClass ideal (x^2,y^2,z^2,x*z)                       |
|                                                                             |
|o6 = H(3,2)                                                                  |
+-----------------------------------------------------------------------------+
|i7 : resLengthThreeTorAlgClass ideal (x^2,y^2,z^2,x*y*z)                     |
|                                                                             |
|o7 = T                                                                       |
+-----------------------------------------------------------------------------+

Caveat
======

The codepth of the ideal I must be exactly 3, and the length of the complex F
must be exactly 3.

Ways to use resLengthThreeTorAlgClass:
======================================

  * "resLengthThreeTorAlgClass(Complex)"
  * "resLengthThreeTorAlgClass(Ideal)"

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

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

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

The source of this document is in ResLengthThree.m2:751:0.