This is TorAlgebra.info, produced by Macaulay2, version 1.25.11

TorAlgebra -- Classification of local rings based on multiplication in homology
*******************************************************************************

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

Let $I$ be an ideal of a regular local ring $Q$ with residue field $k$. The
length of the minimal free resolution of $R=Q/I$ is called the codepth of $R$;
if it is at most $3$, then the resolution carries a structure of a differential
graded algebra. While the DG algebra structure may not be unique, the induced
algebra structure on Tor$^Q$ ($R,k$) is unique and provides for a
classification of such local rings.

According to the multiplicative structure on Tor$^Q$ ($R,k$), a non-zero local
ring $R$ of codepth at most 3 belongs to exactly one of the (parametrized)
classes designated B, C(c), G(r), H(p,q), S, or T. An overview of the theory
can be found in L.L. Avramov,  A cohomological study of local rings of
embedding codepth 3 (see https://doi.org/10.1016/j.jpaa.2012.03.012 ).

There is a similar classification of Gorenstein local rings of codepth 4, due
to A.R. Kustin and M. Miller. There are four classes, which in the original
paper Classification of the Tor-Algebras of Codimension Four Gorenstein Local
rings (see https://doi.org/10.1007/BF01215134 ), are called A, B, C, and D,
while in the survey Homological asymptotics of modules over local rings (see
https://doi.org/10.1007/978-1-4612-3660-3_3 ) by L.L. Avramov, they are called
CI, GGO, GTE, and GH(p), respectively. Here we denote these classes C(c), GS,
GT, and GH(p), respectively.

The package implements an algorithm for classification of local rings in the
sense discussed above. For rings of codepth at most 3 it is described in L.W.
Christensen and O. Veliche, Local rings of embedding codepth 3: A
classification algorithm (see http://dx.doi.org/10.2140/jsag.2014.6.1 ). The
classification of Gorenstein rings of codepth 4 is analogous.

The package also recognizes Golod rings, Gorenstein rings, and complete
intersection rings of any codepth. To recognize Golod rings the package
implements a test found in J. Burke, Higher homotopies and Golod rings (see
https://arxiv.org/abs/1508.03782 ).

Authors
=======

  * Lars Winther Christensen (see http://www.math.ttu.edu/~lchriste/index.html
    ) <lars.w.christensen@ttu.edu>
  * Oana Veliche (see https://web.northeastern.edu/oveliche/index.html )
    <o.veliche@northeastern.edu>

Certification a gold star
=========================

Version 1.0 of this package (under the name "CodepthThree") was accepted for
publication in volume 6 (see https://msp.org/jsag/2014/6-1/ ) of The Journal of
Software for Algebra and Geometry (see https://msp.org/jsag/ ) on 2014-07-11,
in the article Local rings of embedding codepth 3: A classification algorithm
(see https://msp.org/jsag/2014/6-1/p01.xhtml ) (DOI: 10.2140/jsag.2014.6.1 (see
https://doi.org/10.2140/jsag.2014.6.1 )). That version can be obtained from the
journal (see https://msp.org/jsag/2014/6-1/jsag-v6-n1-x01-code.zip ).

Version
=======

This documentation describes version 2.1 of TorAlgebra, released 5 November
2020.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{TorAlgebraSource,                                                      |
|  title = {{TorAlgebra: classification of local rings based on multiplication|
|  author = {Lars Winther Christensen and Oana Veliche},                      |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{TorAlgebraArticle,                                                  |
|  title = {{Local rings of embedding codepth 3: A classification algorithm}},|
|  author = {Lars Winther Christensen and Oana Veliche},                      |
|  journal = {The Journal of Software for Algebra and Geometry},              |
|  volume = {6},                                                              |
|  year = {2014},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|in homology. Version~2.1}},                                                  |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * isCI -- whether the ring is complete intersection
      * isGolod -- whether the ring is Golod
      * isGorenstein -- whether the ring is Gorenstein
      * setAttemptsAtGenericReduction, --
        control the number of attempts to compute Bass numbers via a generic
        reduction
      * torAlgClass -- the class (w.r.t. multiplication in
        homology) of a local ring
      * torAlgData -- invariants of a local ring and its
        class (w.r.t. multiplication in homology)
      * torAlgDataList -- list invariants of a local
        ring
      * torAlgDataPrint -- print invariants of a local
        ring
  * Methods
      * "isCI(QuotientRing)" -- see isCI, -- whether the ring is
        complete intersection
      * isCI(Ideal) -- whether the ring is complete
        intersection
      * "isGolod(QuotientRing)" -- see isGolod, -- whether the
        ring is Golod
      * isGolod(Ideal) -- whether the ring is Golod
      * "isGorenstein(QuotientRing)" -- see isGorenstein,
        -- whether the ring is Gorenstein
      * isGorenstein(Ideal) -- whether the ring
        is Gorenstein
      * "torAlgClass(QuotientRing)" -- see torAlgClass, --
        the class (w.r.t. multiplication in homology) of a local ring
      * torAlgClass(Ideal) -- the class (w.r.t.
        multiplication in homology) of a local ring
      * "torAlgData(QuotientRing)" -- see torAlgData, --
        invariants of a local ring and its class (w.r.t. multiplication in
        homology)
      * torAlgData(Ideal) -- invariants of a
        local ring and its class (w.r.t. multiplication in homology)
      * "torAlgDataList(QuotientRing,List)" -- see torAlgDataList,
        -- list invariants of a local ring
      * torAlgDataList(Ideal,List), --
        list invariants of a local ring
      * "torAlgDataPrint(QuotientRing,List)" -- see torAlgDataPrint,
        -- print invariants of a local ring
      * torAlgDataPrint(Ideal,List),
        -- print invariants of a local ring
  * Symbols
      * attemptsAtGenericReduction -- see
        setAttemptsAtGenericReduction

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

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

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

The source of this document is in TorAlgebra.m2:932:0.

attemptsAtGenericReduction -- see setAttemptsAtGenericReduction
***************************************************************

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

See setAttemptsAtGenericReduction,

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

The object attemptsAtGenericReduction, is a
symbol (Macaulay2Doc).

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

The source of this document is in TorAlgebra.m2:1498:0.

isCI -- whether the ring is complete intersection
*************************************************

  * Usage:
        isCI R or isCI I
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing R at the irrelevant maximal ideal is complete
        intersection

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

Checks if the local ring obtained by localizing R at the irrelevant maximal
ideal is complete intersection. It is also possible to call the function on the
defining ideal of R; see isCI(Ideal).

+------------------------------------+
|i1 : Q = QQ[x,y,z];                 |
+------------------------------------+
|i2 : isCI (Q/ideal(x^2,x*y,y*z,z^2))|
|                                    |
|o2 = false                          |
+------------------------------------+
|i3 : isCI (Q/ideal(x^2,y^2))        |
|                                    |
|o3 = true                           |
+------------------------------------+

Ways to use isCI:
=================

  * "isCI(QuotientRing)"
  * isCI(Ideal) -- whether the ring is complete
    intersection

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

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

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

The source of this document is in TorAlgebra.m2:1188:0.

isCI(Ideal) -- whether the ring is complete intersection
********************************************************

  * Function: isCI,
  * Usage:
        isCI R or isCI I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing the quotient by I at the irrelevant maximal
        ideal is complete intersection

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

Checks if the local ring obtained by localizing the quotient by I at the
irrelevant maximal ideal is complete intersection.

+----------------------------------+
|i1 : Q = QQ[x,y,z];               |
+----------------------------------+
|i2 : isCI (ideal(x^2,x*y,y*z,z^2))|
|                                  |
|o2 = false                        |
+----------------------------------+
|i3 : isCI (ideal(x^2,y^2))        |
|                                  |
|o3 = true                         |
+----------------------------------+

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

  * isCI(Ideal) -- whether the ring is complete
    intersection
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1214:0.

isGolod -- whether the ring is Golod
************************************

  * Usage:
        isGolod R or isGolod I
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing R at the irrelevant maximal ideal is Golod

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

Checks if the local ring obtained by localizing R at the irrelevant maximal
ideal is Golod. It is also possible to call the function on the defining ideal
of R; see isGolod(Ideal).

+---------------------------------------+
|i1 : Q = QQ[x,y,z];                    |
+---------------------------------------+
|i2 : isGolod (Q/ideal(x^2,x*y,y*z,z^2))|
|                                       |
|o2 = false                             |
+---------------------------------------+
|i3 : isGolod (Q/ideal(x^2))            |
|                                       |
|o3 = true                              |
+---------------------------------------+
|i4 : isGolod (Q/(ideal(x,y,z))^2)      |
|                                       |
|o4 = true                              |
+---------------------------------------+

Ways to use isGolod:
====================

  * "isGolod(QuotientRing)"
  * isGolod(Ideal) -- whether the ring is Golod

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

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

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

The source of this document is in TorAlgebra.m2:1299:0.

isGolod(Ideal) -- whether the ring is Golod
*******************************************

  * Function: isGolod,
  * Usage:
        isGolod R or isGolod I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing the quotient by I at the irrelevant maximal
        ideal is Golod

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

Checks if the local ring obtained by localizing the quotient by I at the
irrelevant maximal ideal is Golod.

+-------------------------------------+
|i1 : Q = QQ[x,y,z];                  |
+-------------------------------------+
|i2 : isGolod (ideal(x^2,x*y,y*z,z^2))|
|                                     |
|o2 = false                           |
+-------------------------------------+
|i3 : isGolod (ideal(x^2))            |
|                                     |
|o3 = true                            |
+-------------------------------------+
|i4 : isGolod ((ideal(x,y,z))^2)      |
|                                     |
|o4 = true                            |
+-------------------------------------+

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

  * isGolod(Ideal) -- whether the ring is Golod
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1326:0.

isGorenstein -- whether the ring is Gorenstein
**********************************************

  * Usage:
        isGorenstein R or isGorenstein I
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing R at the irrelevant maximal ideal is Gorenstein

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

Checks if the local ring obtained by localizing R at the irrelevant maximal
ideal is Gorenstein. It is also possible to call the function on the defining
ideal of R; see isGorenstein(Ideal).

+----------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                   |
+----------------------------------------------------------------------+
|i2 : isGorenstein (Q/ideal(x^2,x*y,y*z,z^2))                          |
|                                                                      |
|o2 = false                                                            |
+----------------------------------------------------------------------+
|i3 : isGorenstein (Q/ideal(x^2,y^2))                                  |
|                                                                      |
|o3 = true                                                             |
+----------------------------------------------------------------------+
|i4 : isGorenstein (Q/ideal(x*z+y*z,x*y+y*z,x^2-y*z,y*z^2+z^3,y^3-z^3))|
|                                                                      |
|o4 = true                                                             |
+----------------------------------------------------------------------+

Ways to use isGorenstein:
=========================

  * "isGorenstein(QuotientRing)"
  * isGorenstein(Ideal) -- whether the ring is
    Gorenstein

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

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

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

The source of this document is in TorAlgebra.m2:1243:0.

isGorenstein(Ideal) -- whether the ring is Gorenstein
*****************************************************

  * Function: isGorenstein,
  * Usage:
        isGorenstein R or isGorenstein I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the local ring
        obtained by localizing the quotient by I at the irrelevant maximal
        ideal is Gorenstein

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

Checks if the local ring obtained by localizing the quotient by I at the
irrelevant maximal ideal is Gorenstein.

+--------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                 |
+--------------------------------------------------------------------+
|i2 : isGorenstein (ideal(x^2,x*y,y*z,z^2))                          |
|                                                                    |
|o2 = false                                                          |
+--------------------------------------------------------------------+
|i3 : isGorenstein (ideal(x^2,y^2))                                  |
|                                                                    |
|o3 = true                                                           |
+--------------------------------------------------------------------+
|i4 : isGorenstein (ideal(x*z+y*z,x*y+y*z,x^2-y*z,y*z^2+z^3,y^3-z^3))|
|                                                                    |
|o4 = true                                                           |
+--------------------------------------------------------------------+

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

  * isGorenstein(Ideal) -- whether the ring is
    Gorenstein
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1270:0.

setAttemptsAtGenericReduction -- control the number of attempts to compute Bass numbers via a generic reduction
***************************************************************************************************************

  * Usage:
        setAttemptsAtGenericReduction(R,n)
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
      * n, an integer (Macaulay2Doc), must be non-negative
  * Outputs:
      * an integer (Macaulay2Doc), the number of attempts that will
        be made to perform a generic reduction to compute the Bass numbers of
        the local ring obtained by localizing R at the irrelevant maximal ideal

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

Changes the number of attempts made to reduce R modulo a generic regular
sequence of generators of the irrelevant maximal ideal in order to compute the
Bass numbers of the local ring obtained by localizing R at the irrelevant
maximal ideal. The function has the effect of setting
R.attemptsAtGenericReduction = n, and the number of attempts made is at most
n^2. The default value is 25, so if R.attemptsAtGenericReduction is not set,
then at most 625 attempts are made.

+----------------------------------------------------------------------------+
|i1 : Q = ZZ/2[u,v,w,x,y,z];                                                 |
+----------------------------------------------------------------------------+
|i2 : R = Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);                          |
+----------------------------------------------------------------------------+
|i3 : R.?attemptsAtGenericReduction                                          |
|                                                                            |
|o3 = false                                                                  |
+----------------------------------------------------------------------------+
|i4 : setAttemptsAtGenericReduction(R,100)                                   |
|                                                                            |
|o4 = 10000 attempt(s) will be made to compute the Bass numbers via a generic|
|     reduction                                                              |
+----------------------------------------------------------------------------+
|i5 : R.attemptsAtGenericReduction                                           |
|                                                                            |
|o5 = 100                                                                    |
+----------------------------------------------------------------------------+

If the value of R.attemptsAtGenericReduction is too small, then the computation
of Bass numbers may fail resulting in an error message. Notice, though, that if
the local ring obtained by localizing R at the irrelevant maximal ideal has
embedding dimension at most 3, then the Bass numbers are computed without any
attempt to reduce the ring, and R.attemptsAtGenericReduction has no
significance.

+------------------------------------------------------------------------+
|i6 : Q = ZZ/2[x,y,z];                                                   |
+------------------------------------------------------------------------+
|i7 : R = Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);                      |
+------------------------------------------------------------------------+
|i8 : setAttemptsAtGenericReduction(R,0)                                 |
|                                                                        |
|o8 = 0 attempt(s) will be made to compute the Bass numbers via a generic|
|     reduction                                                          |
+------------------------------------------------------------------------+
|i9 : torAlgClass R                                                      |
|                                                                        |
|o9 = G(3)                                                               |
+------------------------------------------------------------------------+

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

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

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

The source of this document is in TorAlgebra.m2:1486:0.

torAlgClass -- the class (w.r.t. multiplication in homology) of a local ring
****************************************************************************

  * Usage:
        torAlgClass R or torAlgClass I
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
  * Outputs:
      * a string (Macaulay2Doc), the (parametrized) class of the
        local ring obtained by localizing R at the irrelevant maximal ideal,
        provided that this ring is non-zero and of codepth at most 3 or
        Gorenstein or Golod; otherwise "no class"

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

Classifies the local ring obtained by localizing R at the irrelevant maximal
ideal; it is also possible to call the function on the defining ideal of R; see
torAlgClass(Ideal).

If the local ring has codepth at most 3, then it is classified as belonging to
one of the (parametrized) classes B, C(c), G(r), H(p,q), S, or T.

+---------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                  |
+---------------------------------------------------------------------+
|i2 : torAlgClass (Q/ideal(x))                                        |
|                                                                     |
|o2 = C(0)                                                            |
+---------------------------------------------------------------------+
|i3 : torAlgClass (Q/ideal(x*y))                                      |
|                                                                     |
|o3 = C(1)                                                            |
+---------------------------------------------------------------------+
|i4 : torAlgClass (Q/ideal(x^2,y^2))                                  |
|                                                                     |
|o4 = C(2)                                                            |
+---------------------------------------------------------------------+
|i5 : torAlgClass (Q/ideal(x^2,y^2,x*y))                              |
|                                                                     |
|o5 = S                                                               |
+---------------------------------------------------------------------+
|i6 : torAlgClass (Q/ideal(x^2,x*y,y*z,z^2))                          |
|                                                                     |
|o6 = B                                                               |
+---------------------------------------------------------------------+
|i7 : torAlgClass (Q/ideal(x^2,y^2,z^2))                              |
|                                                                     |
|o7 = C(3)                                                            |
+---------------------------------------------------------------------+
|i8 : torAlgClass (Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3))          |
|                                                                     |
|o8 = G(3)                                                            |
+---------------------------------------------------------------------+
|i9 : torAlgClass (Q/ideal(x*z+y*z,x*y+y*z,x^2-y*z,y*z^2+z^3,y^3-z^3))|
|                                                                     |
|o9 = G(5), Gorenstein                                                |
+---------------------------------------------------------------------+
|i10 : torAlgClass (Q/ideal(x^2,y^2,z^2,x*y))                         |
|                                                                     |
|o10 = H(3,2)                                                         |
+---------------------------------------------------------------------+
|i11 : torAlgClass (Q/ideal(x^2,y^2,z^2,x*y*z))                       |
|                                                                     |
|o11 = T                                                              |
+---------------------------------------------------------------------+

If the local ring is Gorenstein or Golod of codepth 4, then it is classified as
belonging to one of the (parametrized) classes C(4), GH(p), GS, GT, or codepth
4 Golod.

+----------------------------------------------------------------------------+
|i12 : Q = QQ[w,x,y,z];                                                      |
+----------------------------------------------------------------------------+
|i13 : torAlgClass (Q/ideal(w^2,x^2,y^2,z^2))                                |
|                                                                            |
|o13 = C(4)                                                                  |
+----------------------------------------------------------------------------+
|i14 : torAlgClass (Q/ideal(y*z,x*z,x*y+z^2,x^2,w*x+y^2+z^2,w^2+w*y+y^2+z^2))|
|                                                                            |
|o14 = GH(5)                                                                 |
+----------------------------------------------------------------------------+
|i15 : torAlgClass (Q/ideal(z^2,x*z,w*z+y*z,y^2,x*y,w*y,x^2,w*x+y*z,w^2+y*z))|
|                                                                            |
|o15 = GS                                                                    |
+----------------------------------------------------------------------------+
|i16 : torAlgClass (Q/ideal(x^2,y^2,z^2,x*w,y*w,z*w,w^3-x*y*z))              |
|                                                                            |
|o16 = GT                                                                    |
+----------------------------------------------------------------------------+
|i17 : torAlgClass (Q/(ideal(w,x,y,z))^2)                                    |
|                                                                            |
|o17 = codepth 4 Golod                                                       |
+----------------------------------------------------------------------------+

If the local ring has codepth at least 5, then it is classified as belonging to
one of the classes C(c), if it is complete intersection, codepth c Gorenstein,
if it is Gorenstein and not complete intersection, codepth c Golod, if it is
Golod, and no class otherwise.

+-----------------------------------------------------------------------------+
|i18 : Q = QQ[u,v,w,x,y,z];                                                   |
+-----------------------------------------------------------------------------+
|i19 : torAlgClass (Q/ideal(u^2,v^2,w^2,x^2+y^2, x^2+z^2))                    |
|                                                                             |
|o19 = C(5)                                                                   |
+-----------------------------------------------------------------------------+
|i20 : torAlgClass (Q/ideal(w^2,v*w,z*w,y*w,v^2,z*v+x*w,y*v,x*v,z^2+x*w,y*z,x*|
|                                                                             |
|o20 = codepth 5 Gorenstein                                                   |
|-----------------------------------------------------------------------------|
|z,y^2+x*w,x*y,x^2))                                                          |
+-----------------------------------------------------------------------------+
|i21 : torAlgClass (Q/ideal(x^2*y^2,x^2*z,y^2*z,u^2*z,v^2*z,w^2*z))           |
|                                                                             |
|o21 = codepth 5 Golod                                                        |
+-----------------------------------------------------------------------------+
|i22 : torAlgClass (Q/ideal(u^2,v^2,w^2,x^2,z^2,x*y^15))                      |
|                                                                             |
|o22 = codepth 6 no class                                                     |
+-----------------------------------------------------------------------------+

If the defining ideal of R is not contained in the irrelevant maximal ideal,
then the resulting local ring is zero, and the function returns zero ring.

+----------------------------------+
|i23 : Q = QQ[x,y,z];              |
+----------------------------------+
|i24 : torAlgClass (Q/ideal(x^2-1))|
|                                  |
|o24 = zero ring                   |
+----------------------------------+

Ways to use torAlgClass:
========================

  * "torAlgClass(QuotientRing)"
  * torAlgClass(Ideal) -- the class (w.r.t.
    multiplication in homology) of a local ring

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

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

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

The source of this document is in TorAlgebra.m2:1134:0.

torAlgClass(Ideal) -- the class (w.r.t. multiplication in homology) of a local ring
***********************************************************************************

  * Function: torAlgClass,
  * Usage:
        torAlgClass R or torAlgClass I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
  * Outputs:
      * a string (Macaulay2Doc), the (parametrized) class of the
        local ring obtained by localizing the quotient by I at the irrelevant
        maximal ideal, provided that this ring is non-zero and of codepth at
        most 3 or Gorenstein or Golod; otherwise "no class"

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

See torAlgClass(QuotientRing).

+-------------------------------------+
|i1 : Q = QQ[x,y,z];                  |
+-------------------------------------+
|i2 : torAlgClass (ideal(x^2,y^2,z^2))|
|                                     |
|o2 = C(3)                            |
+-------------------------------------+

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

  * torAlgClass(Ideal) -- the class (w.r.t.
    multiplication in homology) of a local ring
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1160:0.

torAlgData -- invariants of a local ring and its class (w.r.t. multiplication in homology)
******************************************************************************************

  * Usage:
        torAlgData R or torAlgData I
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra by an ideal contained in the irrelevant maximal ideal
  * Outputs:
      * a hash table (Macaulay2Doc), with invariants of the
        local ring obtained by localizing R at the irrelevant maximal ideal

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

Computes invariants of the local ring obtained by localizing R at the
irrelevant maximal ideal and, provided that it has codepth at most 3,
classifies it as belonging to one of the (parametrized) classes B, C(c), G(r),
H(p,q), S, or T. Rings of higher codepth are classified as C(c) (complete
intersection), Gorenstein, Golod, or no class. Gorenstein rings of codepth 4
are further classified as belonging to one of the (parametrized) classes C(4),
GS, GT, or GH(p). It is also possible to call the function on the defining
ideal of R; see torAlgData(Ideal).

Returns a hash table with the following data of the local ring:

"c": codepth

"e": embedding dimension

"h": Cohen-Macaulay defect

"m": minimal number of generators of defining ideal

"n": type

"Class": class ('B', 'C', 'G', 'GH', 'GS', 'GT', 'H', 'S', 'T', 'Golod',
'Gorenstein' `zero ring', or 'no class')

"p": classification parameter

"q": classification parameter

"r": classification parameter

"isCI": boolean

"isGorenstein": boolean

"isGolod": boolean

"PoincareSeries": Poincar\'e series in closed from (rational function)

"BassSeries": Bass series in closed from (rational function)

+-----------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                              |
+-----------------------------------------------------------------+
|i2 : data = torAlgData (Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3))|
|                                                                 |
|                                          2    3    4            |
|                               2 + 2T - 2T  - T  + T             |
|o2 = HashTable{"BassSeries" => ----------------------    }       |
|                                         2     3    4            |
|                               1 - T - 5T  - 2T  + T             |
|               "c" => 3                                          |
|               "Class" => G                                      |
|               "e" => 3                                          |
|               "h" => 0                                          |
|               "isCI" => false                                   |
|               "isGolod" => false                                |
|               "isGorenstein" => false                           |
|               "m" => 6                                          |
|               "n" => 2                                          |
|               "p" => 0                                          |
|                                                 2               |
|                                          (1 + T)                |
|               "PoincareSeries" => ----------------------        |
|                                             2     3    4        |
|                                   1 - T - 5T  - 2T  + T         |
|               "q" => 1                                          |
|               "r" => 3                                          |
|                                                                 |
|o2 : HashTable                                                   |
+-----------------------------------------------------------------+
|i3 : data#"PoincareSeries"                                       |
|                                                                 |
|                   2                                             |
|            (1 + T)                                              |
|o3 = ----------------------                                      |
|               2     3    4                                      |
|     1 - T - 5T  - 2T  + T                                       |
|                                                                 |
|o3 : Expression of class Divide                                  |
+-----------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i4 : Q = QQ[w,x,y,z];                                                        |
+-----------------------------------------------------------------------------+
|i5 : torAlgData (Q/ideal(w^2-x*y*z,x^3,y^3,x^2*z,y^2*z,z^3-x*y*w,x*z*w,y*z*w,|
|                                                                             |
|o5 = HashTable{"BassSeries" => 1                          }                  |
|               "c" => 4                                                      |
|               "Class" => GH                                                 |
|               "e" => 4                                                      |
|               "h" => 0                                                      |
|               "isCI" => false                                               |
|               "isGolod" => false                                            |
|               "isGorenstein" => true                                        |
|               "m" => 9                                                      |
|               "n" => 1                                                      |
|               "p" => 2                                                      |
|                                                  2                          |
|                                           (1 + T)                           |
|               "PoincareSeries" => -----------------------                   |
|                                              2     4    5                   |
|                                   1 - 2T - 6T  + 2T  - T                    |
|               "q" => 3                                                      |
|               "r" => 9                                                      |
|                                                                             |
|o5 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|z^2*w-x^2*y^2))                                                              |
+-----------------------------------------------------------------------------+
+----------------------------------------------------------------+
|i6 : Q = QQ[v,w,x,y,z];                                         |
+----------------------------------------------------------------+
|i7 : torAlgData (Q/(ideal(v^2-w^3)*ideal(v,w,x,y,z)))           |
|                                                                |
|                                          2     3    4    5     |
|                               1 + 4T + 6T  + 4T  + T  - T      |
|o7 = HashTable{"BassSeries" => ----------------------------    }|
|                                         2     3     4    5     |
|                               1 - T - 4T  - 6T  - 4T  - T      |
|               "c" => 5                                         |
|               "Class" => Golod                                 |
|               "e" => 5                                         |
|               "h" => 4                                         |
|               "isCI" => false                                  |
|               "isGolod" => true                                |
|               "isGorenstein" => false                          |
|               "m" => 5                                         |
|               "n" => 1                                         |
|               "p" => 0                                         |
|                                                    4           |
|                                             (1 + T)            |
|               "PoincareSeries" => ---------------------------- |
|                                             2     3     4    5 |
|                                   1 - T - 4T  - 6T  - 4T  - T  |
|               "q" => 0                                         |
|               "r" => -                                         |
|                                                                |
|o7 : HashTable                                                  |
+----------------------------------------------------------------+
+-----------------------------------------------------+
|i8 : Q = QQ[u,v,w,x,y,z];                            |
+-----------------------------------------------------+
|i9 : torAlgData (Q/ideal(u^2,v^2,w^2-y^4,x^2,x*y^15))|
|                                                     |
|o9 = HashTable{"BassSeries" => UNDETERMINED    }     |
|               "c" => 5                              |
|               "Class" => no class                   |
|               "e" => 6                              |
|               "h" => 1                              |
|               "isCI" => false                       |
|               "isGolod" => false                    |
|               "isGorenstein" => false               |
|               "m" => 5                              |
|               "n" => 1                              |
|               "p" => UNDETERMINED                   |
|               "PoincareSeries" => UNDETERMINED      |
|               "q" => UNDETERMINED                   |
|               "r" => -                              |
|                                                     |
|o9 : HashTable                                       |
+-----------------------------------------------------+

To extract data from the hash table returned by the function one may use
torAlgDataList, and torAlgDataPrint.

Caveat
======

If the embedding dimension of R is large, then the response time may be longer,
in particular if R is a quotient of a polynomial algebra over a small field.
The reason is that the function attempts to reduce R modulo a generic regular
sequence of generators of the irrelevant maximal ideal. The total number of
attempts made can be controlled with setAttemptsAtGenericReduction.

If R is a quotient of a polynomial algebra by a homogeneous ideal, then it is
graded and the relevant invariants of the local ring obtained by localizing R
at the irrelevant maximal ideal can be determined directly from R. If R is a
quotient of a polynomial algebra by a non-homogeneous ideal, then the function
uses the package LocalRings, to compute some of the
invariants.

Ways to use torAlgData:
=======================

  * "torAlgData(QuotientRing)"
  * torAlgData(Ideal) -- invariants of a local
    ring and its class (w.r.t. multiplication in homology)

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

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

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

The source of this document is in TorAlgebra.m2:1032:0.

torAlgData(Ideal) -- invariants of a local ring and its class (w.r.t. multiplication in homology)
*************************************************************************************************

  * Function: torAlgData,
  * Usage:
        torAlgData R or torAlgData I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
  * Outputs:
      * a hash table (Macaulay2Doc), with invariants of the
        local ring obtained by localizing the quotient by I at the irrelevant
        maximal ideal

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

See torAlgData(QuotientRing).

+---------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                            |
+---------------------------------------------------------------+
|i2 : data = torAlgData (ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3))|
|                                                               |
|                                          2    3    4          |
|                               2 + 2T - 2T  - T  + T           |
|o2 = HashTable{"BassSeries" => ----------------------    }     |
|                                         2     3    4          |
|                               1 - T - 5T  - 2T  + T           |
|               "c" => 3                                        |
|               "Class" => G                                    |
|               "e" => 3                                        |
|               "h" => 0                                        |
|               "isCI" => false                                 |
|               "isGolod" => false                              |
|               "isGorenstein" => false                         |
|               "m" => 6                                        |
|               "n" => 2                                        |
|               "p" => 0                                        |
|                                                 2             |
|                                          (1 + T)              |
|               "PoincareSeries" => ----------------------      |
|                                             2     3    4      |
|                                   1 - T - 5T  - 2T  + T       |
|               "q" => 1                                        |
|               "r" => 3                                        |
|                                                               |
|o2 : HashTable                                                 |
+---------------------------------------------------------------+
|i3 : data#"PoincareSeries"                                     |
|                                                               |
|                   2                                           |
|            (1 + T)                                            |
|o3 = ----------------------                                    |
|               2     3    4                                    |
|     1 - T - 5T  - 2T  + T                                     |
|                                                               |
|o3 : Expression of class Divide                                |
+---------------------------------------------------------------+

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

  * torAlgData(Ideal) -- invariants of a local
    ring and its class (w.r.t. multiplication in homology)
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1057:0.

torAlgDataList -- list invariants of a local ring
*************************************************

  * Usage:
        torAlgDataList(R,L) or torAlgDataList(I,L)
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra  by an ideal contained in the irrelevant maximal ideal
      * L, a list (Macaulay2Doc), of keys from the hash table
        returned by torAlgData,
  * Outputs:
      * a list (Macaulay2Doc), of values corresponding to the keys
        specified in L

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

Extracts data from the hash table returned by torAlgData.
It is also possible to call the function on the defining ideal of R; see
torAlgDataList(Ideal,List).

+----------------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                         |
+----------------------------------------------------------------------------+
|i2 : R = Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);                          |
+----------------------------------------------------------------------------+
|i3 : torAlgDataList( R, {m, n, Class, p, q, r, PoincareSeries, BassSeries} )|
|                                                                            |
|                                      2                    2    3    4      |
|                               (1 + T)          2 + 2T - 2T  - T  + T       |
|o3 = {6, 2, G, 0, 1, 3, ----------------------, ----------------------}     |
|                                  2     3    4            2     3    4      |
|                        1 - T - 5T  - 2T  + T   1 - T - 5T  - 2T  + T       |
|                                                                            |
|o3 : List                                                                   |
+----------------------------------------------------------------------------+

Ways to use torAlgDataList:
===========================

  * "torAlgDataList(QuotientRing,List)"
  * torAlgDataList(Ideal,List) -- list
    invariants of a local ring

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

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

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

The source of this document is in TorAlgebra.m2:1355:0.

torAlgDataList(Ideal,List) -- list invariants of a local ring
*************************************************************

  * Function: torAlgDataList,
  * Usage:
        torAlgDataList(R,L) or torAlgDataList(I,L)
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
      * L, a list (Macaulay2Doc), of keys from the hash table
        returned by torAlgData,
  * Outputs:
      * a list (Macaulay2Doc), of values corresponding to the keys
        specified in L

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

Extracts data from the hash table returned by torAlgData.

+----------------------------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                                         |
+----------------------------------------------------------------------------+
|i2 : I = ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);                            |
|                                                                            |
|o2 : Ideal of Q                                                             |
+----------------------------------------------------------------------------+
|i3 : torAlgDataList( I, {m, n, Class, p, q, r, PoincareSeries, BassSeries} )|
|                                                                            |
|                                      2                    2    3    4      |
|                               (1 + T)          2 + 2T - 2T  - T  + T       |
|o3 = {6, 2, G, 0, 1, 3, ----------------------, ----------------------}     |
|                                  2     3    4            2     3    4      |
|                        1 - T - 5T  - 2T  + T   1 - T - 5T  - 2T  + T       |
|                                                                            |
|o3 : List                                                                   |
+----------------------------------------------------------------------------+

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

  * torAlgDataList(Ideal,List) -- list
    invariants of a local ring
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1382:0.

torAlgDataPrint -- print invariants of a local ring
***************************************************

  * Usage:
        torAlgDataPrint (R,L) or torAlgDataPrint(I,L)
  * Inputs:
      * R, a quotient ring (Macaulay2Doc), of a polynomial
        algebra  by an ideal contained in the irrelevant maximal ideal
      * L, a list (Macaulay2Doc), of keys from the hash table
        returned by torAlgData,
  * Outputs:
      * a string (Macaulay2Doc), of keys specified in L together
        with their values

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

Extracts data from the hash table returned by torAlgData. It
is also possible to call the function on the defining ideal of R; see
torAlgDataPrint(Ideal,List).

+----------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                       |
+----------------------------------------------------------+
|i2 : R = Q/ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);        |
+----------------------------------------------------------+
|i3 : torAlgDataPrint( R, {c, e, h, m, n, Class, p, q, r} )|
|                                                          |
|o3 = c=3 e=3 h=0 m=6 n=2 Class=G p=0 q=1 r=3              |
+----------------------------------------------------------+

Ways to use torAlgDataPrint:
============================

  * "torAlgDataPrint(QuotientRing,List)"
  * torAlgDataPrint(Ideal,List), --
    print invariants of a local ring

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

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

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

The source of this document is in TorAlgebra.m2:1410:0.

torAlgDataPrint(Ideal,List) -- print invariants of a local ring
***************************************************************

  * Function: torAlgDataPrint,
  * Usage:
        torAlgDataPrint (R,L) or torAlgDataPrint(I,L)
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a polynomial algebra
        contained in the irrelevant maximal ideal
      * L, a list (Macaulay2Doc), of keys from the hash table
        returned by torAlgData,
  * Outputs:
      * a string (Macaulay2Doc), of keys specified in L together
        with their values

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

Extracts data from the hash table returned by torAlgData.

+----------------------------------------------------------+
|i1 : Q = QQ[x,y,z];                                       |
+----------------------------------------------------------+
|i2 : I = ideal(x*y,y*z,x^3,x^2*z,x*z^2-y^3,z^3);          |
|                                                          |
|o2 : Ideal of Q                                           |
+----------------------------------------------------------+
|i3 : torAlgDataPrint( I, {c, e, h, m, n, Class, p, q, r} )|
|                                                          |
|o3 = c=3 e=3 h=0 m=6 n=2 Class=G p=0 q=1 r=3              |
+----------------------------------------------------------+

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

  * torAlgDataPrint(Ideal,List), --
    print invariants of a local ring
-------------------------------------------------------------------------------

The source of this document is in TorAlgebra.m2:1436:0.