This is ResidualIntersections.info, produced by Macaulay2, version 1.20

ResidualIntersections -- Tests for the conditions used in the theory of residual intersections
**********************************************************************************************

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

Definition: If I \subset S is an ideal in a polynomial ring (or Gorenstein
ring) and a_1..a_s are elements of I, then K = (a_1..a_s):I is called an
s-residual intersection of I if the codimension of K is at least s.

In the simplest case, s == codim I, the ideal K is said to be linked to I if
also I = (a_1..a_s):K; this is automatic when S/I is Cohen-Macaulay, and in
this case S/K is also Cohen-Macaulay; see Peskine-Szpiro, Liaison des
variétés algébriques. I. Invent. Math. 26 (1974), 271–302).

The theory for s>c, which has been used in algebraic geometry since the 19th
century, was initiated in a commutative algebra setting by Artin and Nagata in
the paper Residual intersections in Cohen-Macaulay rings. J. Math. Kyoto Univ.
12 (1972), 307–323.

Craig Huneke (Strongly Cohen-Macaulay schemes and residual intersections,
Trans. Amer. Math. Soc. 277 (1983), no. 2, 739–763) proved that an s-residual
intersection K is Cohen-Macaulay if I satisfies the G_d condition and is
strongly Cohen-Macaulay, and successive authors have weakened the latter
condition to sliding depth, and, most recently, Bernd Ulrich (Artin-Nagata
properties and reductions of ideals. Commutative algebra: syzygies,
multiplicities, and birational algebra, Contemp. Math., 159, 1994) showed that
the weaker condition depth( S/(I^t) ) >= dim(S/I) - (t-1) for t = 1..s-codim I
+1 suffices. All these properties are true if I is licci.

This package implements tests for most of these properties.

See also
========

  * isLicci -- Tests whether an ideal is licci
  * residualCodims -- a list of possible residual
    intersection codimensions
  * genericResidual -- Computes generic residual
    intersections of an ideal
  * residualCodims -- a list of possible residual
    intersection codimensions
  * genericArtinNagata -- Generic Artin nagata
  * numgensByCodim -- maximum number of generators of
    localizations of a monomial ideal
  * maxGs -- maximum G_s of a monomial ideal
  * koszulDepth -- Computes the depths of the Koszul
    homology
  * hasSlidingDepth -- Checks if an ideal has the
    sliding depth property
  * isStronglyCM -- Checks if the given ideal is Strongly
    Cohen Macaulay
  * depthsOfPowers -- Computes depth of powers of an
    ideal

Authors
=======

  * Katie Ansaldi <kansaldi@gmail.com>
  * David Eisenbud (see http://www.msri.org/~de ) <de@msri.org>
  * Robert Krone (see http://rckr.one ) <rckrone@gmail.com>
  * Jay Yang <jkelleyy@gmail.com>

Version
=======

This documentation describes version 1.1 of ResidualIntersections.

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

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

Exports
=======

  * Functions and commands
      * depthsOfPowers -- Computes depth of powers of an
        ideal
      * genericArtinNagata -- Generic Artin nagata
      * genericResidual -- Computes generic residual
        intersections of an ideal
      * hasSlidingDepth -- Checks if an ideal has the
        sliding depth property
      * isLicci -- Tests whether an ideal is licci
      * isStronglyCM -- Checks if the given ideal is
        Strongly Cohen Macaulay
      * koszulDepth -- Computes the depths of the Koszul
        homology
      * linkageBound -- computes a bound on the number of
        general links of an ideal to test the licci property
      * maxGs -- maximum G_s of a monomial ideal
      * numgensByCodim -- maximum number of generators
        of localizations of a monomial ideal
      * residualCodims -- a list of possible residual
        intersection codimensions
  * Methods
      * "depthsOfPowers(ZZ,Ideal)" -- see depthsOfPowers,
        -- Computes depth of powers of an ideal
      * "depthsOfPowers(ZZ,ZZ,Ideal)" -- see depthsOfPowers,
        -- Computes depth of powers of an ideal
      * "genericArtinNagata(ZZ,Ideal)" -- see genericArtinNagata,
        -- Generic Artin nagata
      * "genericResidual(ZZ,Ideal)" -- see genericResidual,
        -- Computes generic residual intersections of an ideal
      * "hasSlidingDepth(ZZ,Ideal)" -- see hasSlidingDepth,
        -- Checks if an ideal has the sliding depth property
      * "isLicci(Ideal)" -- see isLicci, -- Tests whether an
        ideal is licci
      * "isLicci(ZZ,Ideal)" -- see isLicci, -- Tests whether an
        ideal is licci
      * "isLicci(ZZ,ZZ,Ideal)" -- see isLicci, -- Tests whether
        an ideal is licci
      * "isStronglyCM(Ideal)" -- see isStronglyCM, --
        Checks if the given ideal is Strongly Cohen Macaulay
      * "koszulDepth(Ideal)" -- see koszulDepth, -- Computes
        the depths of the Koszul homology
      * "koszulDepth(ZZ,Ideal)" -- see koszulDepth, --
        Computes the depths of the Koszul homology
      * "linkageBound(Ideal)" -- see linkageBound, --
        computes a bound on the number of general links of an ideal to test the
        licci property
      * "maxGs(MonomialIdeal)" -- see maxGs, -- maximum G_s of a
        monomial ideal
      * "numgensByCodim(MonomialIdeal)" -- see numgensByCodim,
        -- maximum number of generators of localizations of a
        monomial ideal
      * "numgensByCodim(MonomialIdeal,ZZ)" -- see numgensByCodim,
        -- maximum number of generators of localizations of a
        monomial ideal
      * "residualCodims(MonomialIdeal)" -- see residualCodims,
        -- a list of possible residual intersection
        codimensions
  * Symbols
      * UseNormalModule -- option for linkageBound and
        isLicci

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

The object ResidualIntersections, is a package (Macaulay2Doc).

depthsOfPowers -- Computes depth of powers of an ideal
******************************************************

Synopsis
========

  * Usage:
        L = depthsOfPowers(s,c,I)
        L = depthsOfPowers(s,I)
  * Inputs:
      * s, an integer (Macaulay2Doc), number of powers to compute
      * c, an integer (Macaulay2Doc), (If omitted, it will use c =
        codim I)
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), The depths of the powers of I
        from 1 to s-c+1.

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

Computes the depth of $S/I^k$ for $k$ from 1 to $s-c+1$.

+------------------------------------------------+
|i1 : R = QQ[a,b,c,d,e,f];                       |
+------------------------------------------------+
|i2 : I = ideal (b*c, b*d, b*e, d*e, a*d*f, e*f);|
|                                                |
|o2 : Ideal of R                                 |
+------------------------------------------------+
|i3 : depthsOfPowers(6,3,I)                      |
|                                                |
|o3 = {3, 1, 1, 1}                               |
|                                                |
|o3 : List                                       |
+------------------------------------------------+

Caveat
======

Ways to use depthsOfPowers :
============================

  * "depthsOfPowers(ZZ,Ideal)"
  * "depthsOfPowers(ZZ,ZZ,Ideal)"

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

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

genericArtinNagata -- Generic Artin nagata
******************************************

Synopsis
========

  * Usage:
        L = genericArtinNagata(s,I)
  * Inputs:
      * s, an integer (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc),

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

forms an ideal F generated by s generic linear combinations of the generators
of I in the degree of the highest degree generator, and computes K = F:I. If
the codimension of K is not equal to s, returns {-1,K}. Otherwise returns
{codepth R/K,K}, where codepth R/K is the deviation from Cohen-Macaulayness.
Thus genericArtinNagata(s,I)_0 = 0 means that K is an s-residual intersection
of codim s and R/K is Cohen-Macaulay.

If I is a monomial idal, the function residualCodims I returns the list of
codimensions s for which there might be a residual intersection of codimension
s.

In the following example, all the generic residual intersectionsa are
Cohen-Macaulay, until we get to the 6-residual intersection, which cannot be
codim 6 because there are only 5 variables.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : S = ZZ/101[a,b,c,d,e]                                                   |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : I = minors(2, random(S^2, S^{3:-1}))                                    |
|                                                                             |
|               2              2                      2                       |
|o3 = ideal (45a  + 24a*b - 50b  + 10a*c + 48b*c + 45c  - 49a*d - 50b*d -     |
|     ------------------------------------------------------------------------|
|                2                                  2     2              2    |
|     10c*d + 23d  + 3a*e - 7b*e + 8c*e - 4d*e + 16e , 22a  + 45a*b + 17b  +  |
|     ------------------------------------------------------------------------|
|                     2                             2                         |
|     36a*c + b*c + 6c  - 31a*d - 13b*d - 4c*d + 22d  - 27a*e - 30b*e + 44c*e |
|     ------------------------------------------------------------------------|
|                 2     2             2                      2                |
|     + 21d*e + 4e , 24a  + 2a*b + 35b  + 44a*c + 15b*c + 34c  - 41a*d + 18b*d|
|     ------------------------------------------------------------------------|
|                  2                                      2                   |
|     + 48c*d + 49d  + 41a*e - 15b*e + 16c*e - 13d*e - 32e )                  |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i4 : apply(5, i-> (genericArtinNagata(i+2,I))_0)                             |
|                                                                             |
|o4 = {0, 0, 0, 0, -1}                                                        |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : I = randomShellableIdeal(S,2,4)                                         |
|                                                                             |
|o5 = monomialIdeal (b*c, b*d, c*d*e)                                         |
|                                                                             |
|o5 : MonomialIdeal of S                                                      |
+-----------------------------------------------------------------------------+
|i6 : residualCodims I                                                        |
|                                                                             |
|o6 = {3, 4, 5, 6}                                                            |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : apply(5, i-> (genericArtinNagata(i+2,I))_0)                             |
|                                                                             |
|o7 = {0, 0, 0, 0, -1}                                                        |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

Ways to use genericArtinNagata :
================================

  * "genericArtinNagata(ZZ,Ideal)"

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

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

genericResidual -- Computes generic residual intersections of an ideal
**********************************************************************

Synopsis
========

  * Usage:
        K = genericResidual(s,I)
  * Inputs:
      * s, an integer (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * K, an ideal (Macaulay2Doc),

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

returns K = F:J where F is generated by s elements chosend at random from
elements of degrees e_1...e_s in the ideal. If the degrees of the the
generators of the ideal are d_1<=...<=d_n, then the e_i = d_(n-s+i) if s<=n,
and otherwise d_1+1...d_n+1, d_n+1...d_n+1.

The call genericArtinNagata calls genericResidual,and produces a list where the
first item is the codepth of (ring I)/K (or -1 if K is not of codim 2), and the
second item is K.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : S = ZZ/101[a,b,c,d,e]                                                   |
|                                                                             |
|o2 = S                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : I = minors(2, random(S^2, S^{3:-1}))                                    |
|                                                                             |
|               2              2                      2                       |
|o3 = ideal (45a  + 24a*b - 50b  + 10a*c + 48b*c + 45c  - 49a*d - 50b*d -     |
|     ------------------------------------------------------------------------|
|                2                                  2     2              2    |
|     10c*d + 23d  + 3a*e - 7b*e + 8c*e - 4d*e + 16e , 22a  + 45a*b + 17b  +  |
|     ------------------------------------------------------------------------|
|                     2                             2                         |
|     36a*c + b*c + 6c  - 31a*d - 13b*d - 4c*d + 22d  - 27a*e - 30b*e + 44c*e |
|     ------------------------------------------------------------------------|
|                 2     2             2                      2                |
|     + 21d*e + 4e , 24a  + 2a*b + 35b  + 44a*c + 15b*c + 34c  - 41a*d + 18b*d|
|     ------------------------------------------------------------------------|
|                  2                                      2                   |
|     + 48c*d + 49d  + 41a*e - 15b*e + 16c*e - 13d*e - 32e )                  |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i4 : assert(genericResidual(5,I) == (ideal vars S)^3)                        |
+-----------------------------------------------------------------------------+
|i5 : (genericArtinNagata(5,I))_0                                             |
|                                                                             |
|o5 = 0                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * genericArtinNagata -- Generic Artin nagata
  * residualCodims -- a list of possible residual
    intersection codimensions

Ways to use genericResidual :
=============================

  * "genericResidual(ZZ,Ideal)"

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

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

hasSlidingDepth -- Checks if an ideal has the sliding depth property
********************************************************************

Synopsis
========

  * Usage:
        b = hasSlidingDepth(k,I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
      * k, an integer (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), true if I has sliding
        depth

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

Determines whether the ideal I has sliding depth for k steps

Let K be the Koszul complex on a minimal set of generators of I. We say $I$ has
k-sliding depth if for all $i\leq k$ we have $depth(H_{n-codim(I)-i}(K) \geq
dim I - i$. Note that if I is perfect then  $H_{n-codim(I)}(K)$ is the
canonical module, which is Cohen-Macaulay so that I has 0-sliding depth.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_6];                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = minors(2, genericSymmetricMatrix(R,x_1,3))                          |
|                                                                             |
|               2                                                         2   |
|o2 = ideal (- x  + x x , - x x  + x x , - x x  + x x , - x x  + x x , - x  + |
|               2    1 4     2 3    1 5     3 4    2 5     2 3    1 5     3   |
|     ------------------------------------------------------------------------|
|                                                           2                 |
|     x x , - x x  + x x , - x x  + x x , - x x  + x x , - x  + x x )         |
|      1 6     3 5    2 6     3 4    2 5     3 5    2 6     5    4 6          |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : c = codim I                                                             |
|                                                                             |
|o3 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i4 : m = numgens I                                                           |
|                                                                             |
|o4 = 9                                                                       |
+-----------------------------------------------------------------------------+
|i5 : apply (m+1, i-> koszulDepth(i,I))                                       |
|                                                                             |
|o5 = {3, 1, 3, 3, 6, 6, 6, 6, 6, 6}                                          |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : hasSlidingDepth(m-c,I)                                                  |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+
|i7 : I = ideal{x_1*x_2,x_1*x_3,x_2*x_4*x_5,x_1*x_6,x_4*x_6,x_5*x_6};         |
|                                                                             |
|o7 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i8 : hasSlidingDepth(1,I)                                                    |
|                                                                             |
|o8 = true                                                                    |
+-----------------------------------------------------------------------------+
|i9 : hasSlidingDepth(2,I)                                                    |
|                                                                             |
|o9 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * isStronglyCM -- Checks if the given ideal is Strongly
    Cohen Macaulay
  * koszulDepth -- Computes the depths of the Koszul
    homology

Ways to use hasSlidingDepth :
=============================

  * "hasSlidingDepth(ZZ,Ideal)"

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

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

isLicci -- Tests whether an ideal is licci
******************************************

Synopsis
========

  * Usage:
        L = isLicci(b,c,I)
        L = isLicci(b,I)
        L = isLicci I
  * Inputs:
      * b, an integer (Macaulay2Doc), upper bound on how many
        successive random links to try
      * c, an integer (Macaulay2Doc), codim of I
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * UseNormalModule, => ..., default value false,
        option for linkageBound and isLicci
      * Verbose => ..., default value false
  * Outputs:
      * L, a list (Macaulay2Doc), of integers, the numbers of
        generators of the successive links

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

Computes up to b successive random links, using a regular sequence among the
generators of I, and outputs the numbers of generators. If I is licci, such a
sequence must terminate in an ideal with c = codim I generators in at most
linkageBound I steps.

Every perfect codimension 2 ideal (nxn minors of an (nx(n+1) matrix) is licci,
but other ideals of minors are generally not, as illustrated below.

+-----------------------------------------------------------------------------+
|i1 : setRandomSeed 0                                                         |
|                                                                             |
|o1 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i2 : needsPackage "RandomIdeals"                                             |
|                                                                             |
|o2 = RandomIdeals                                                            |
|                                                                             |
|o2 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i3 : S = ZZ/32003[x_0..x_6]                                                  |
|                                                                             |
|o3 = S                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : L = idealChainFromShelling(S,randomShelling(7,3,8))                     |
|                                                                             |
|o4 = {monomialIdeal (x , x , x ), monomialIdeal (x , x , x x ), monomialIdeal|
|                      0   1   3                   1   3   0 5                |
|     ------------------------------------------------------------------------|
|     (x , x x , x x , x x ), monomialIdeal (x , x x x , x x , x x ),         |
|       3   1 4   0 5   1 5                   3   0 1 4   0 5   1 5           |
|     ------------------------------------------------------------------------|
|     monomialIdeal (x , x x x , x x , x x x ), monomialIdeal (x , x x x ,    |
|                     3   0 1 4   1 5   0 4 5                   3   0 1 4     |
|     ------------------------------------------------------------------------|
|     x x , x x x x ), monomialIdeal (x , x x x , x x x , x x x , x x x x ),  |
|      1 5   0 4 5 6                   3   0 1 4   0 1 5   1 4 5   0 4 5 6    |
|     ------------------------------------------------------------------------|
|     monomialIdeal (x x , x x , x x x , x x x , x x , x x x , x x x x )}     |
|                     0 3   2 3   0 1 4   0 1 5   3 5   1 4 5   0 4 5 6       |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : apply(L, I-> {linkageBound I, linkageBound(I, UseNormalModule =>true)}) |
|                                                                             |
|o5 = {{0, 0}, {0, 0}, {6, 2}, {12, 2}, {18, 2}, {24, 2}, {30, 14}, {36, 18}} |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : scan(L, I ->print isLicci(I, UseNormalModule => true))                  |
|true                                                                         |
|true                                                                         |
|true                                                                         |
|true                                                                         |
|true                                                                         |
|true                                                                         |
|true                                                                         |
|false                                                                        |
+-----------------------------------------------------------------------------+

Caveat
======

linkageBound I can be very large; linkageBound(I, UseNormalModule => true) can
be slow.

See also
========

  * linkageBound -- computes a bound on the number of
    general links of an ideal to test the licci property

Ways to use isLicci :
=====================

  * "isLicci(Ideal)"
  * "isLicci(ZZ,Ideal)"
  * "isLicci(ZZ,ZZ,Ideal)"

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

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

isStronglyCM -- Checks if the given ideal is Strongly Cohen Macaulay
********************************************************************

Synopsis
========

  * Usage:
        b = isStronglyCM I
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), true if I is Strongly
        Cohen Macaulay

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

I is Strongly Cohen Macaulay if each Koszul homology module is Cohen-Macaulay.
The routine computes the Koszul homology with koszulDepth.

+--------------------------------------------------------+
|i1 : R = ZZ/101[x_1..x_5];                              |
+--------------------------------------------------------+
|i2 : I = ideal{x_1*x_3,x_2*x_4,x_3*x_4,x_1*x_5,x_3*x_5};|
|                                                        |
|o2 : Ideal of R                                         |
+--------------------------------------------------------+
|i3 : isStronglyCM I                                     |
|                                                        |
|o3 = true                                               |
+--------------------------------------------------------+

See also
========

  * koszulDepth -- Computes the depths of the Koszul
    homology
  * hasSlidingDepth -- Checks if an ideal has the
    sliding depth property

Ways to use isStronglyCM :
==========================

  * "isStronglyCM(Ideal)"

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

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

koszulDepth -- Computes the depths of the Koszul homology
*********************************************************

Synopsis
========

  * Usage:
        L = koszulDepth I
        d = koszulDepth(k,I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
      * k, an integer (Macaulay2Doc), the homological index to
        compute
  * Outputs:
      * L, a list (Macaulay2Doc), a list of the depths of Kozul
        homology
      * d, an integer (Macaulay2Doc), the depth of the k-th Koszul
        homology

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

The one parameter version computes the depths of the non-vanishing Koszul
homology of I. The two parameter version computes only the depth of the k-th
Koszul homology.

+--------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_6];                                              |
+--------------------------------------------------------------------+
|i2 : I = ideal{x_1*x_2,x_1*x_3,x_2*x_4*x_5,x_1*x_6,x_4*x_6,x_5*x_6};|
|                                                                    |
|o2 : Ideal of R                                                     |
+--------------------------------------------------------------------+
|i3 : koszulDepth I                                                  |
|                                                                    |
|o3 = {3, 0, 2}                                                      |
|                                                                    |
|o3 : List                                                           |
+--------------------------------------------------------------------+
|i4 : koszulDepth(2,I)                                               |
|                                                                    |
|o4 = 2                                                              |
+--------------------------------------------------------------------+

See also
========

  * isStronglyCM -- Checks if the given ideal is Strongly
    Cohen Macaulay
  * hasSlidingDepth -- Checks if an ideal has the
    sliding depth property

Ways to use koszulDepth :
=========================

  * "koszulDepth(Ideal)"
  * "koszulDepth(ZZ,Ideal)"

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

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

linkageBound -- computes a bound on the number of general links of an ideal to test the licci property
******************************************************************************************************

Synopsis
========

  * Usage:
        b = linkageBound I
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * UseNormalModule, => ..., default value false,
        option for linkageBound and isLicci
  * Outputs:
      * b, an integer (Macaulay2Doc),

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

An ideal I in a polynomial ring S is licci if it Cohen-Macaulay and is linked
in finitely many steps I --> (F):I, where F is a maximal regular sequence in I,
to a complete intersection. Bernd Ulrich showed that if I is licci and each
step of the linkage is done via a regular sequence F that is a subset of a
minimal set of generators, then the linkage process will terminate after at
most b steps, where

b = 2(codim I)*(degree I -1) -6.

(Theorem 2.4 of "On Licci Ideals", Contemp. Math 88 (1989). This is computed by
linkageBound I. He did this via a more refined formula; the (generally sharper)
intermediate result gives the bound

b = 2(numgens(Hom(I, S/I) - codim I).

The call linkageBound(I, UseNormalModule =>true) computes this refined bound.
See isLicci for examples.

Caveat
======

The crude bound can be quite large; computing the refined bound (which is often
large as well) can be quite slow.

See also
========

  * isLicci -- Tests whether an ideal is licci
  * UseNormalModule -- option for linkageBound and
    isLicci

Ways to use linkageBound :
==========================

  * "linkageBound(Ideal)"

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

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

maxGs -- maximum G_s of a monomial ideal
****************************************

Synopsis
========

  * Usage:
        d = maxGs I
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
  * Outputs:
      * d, an integer (Macaulay2Doc), the maximum value of s such
        that I has property G_s (possibly infinity).

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

Recall that an ideal I has the property G_s if, for every prime P with codim P
<s, the localization I_P is generated by at most codim P elements. For example,
if s = codim I, then I is G_s iff I is generically a complete intersection.

+------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,x_3];                                   |
+------------------------------------------------------------+
|i2 : I = monomialIdeal(x_1^2,x_1*x_2,x_1*x_3,x_2^2,x_2*x_3);|
|                                                            |
|o2 : MonomialIdeal of R                                     |
+------------------------------------------------------------+
|i3 : maxGs(I)                                               |
|                                                            |
|o3 = 3                                                      |
+------------------------------------------------------------+

Caveat
======

See also
========

  * numgensByCodim -- maximum number of generators of
    localizations of a monomial ideal
  * residualCodims -- a list of possible residual
    intersection codimensions

Ways to use maxGs :
===================

  * "maxGs(MonomialIdeal)"

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

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

numgensByCodim -- maximum number of generators of localizations of a monomial ideal
***********************************************************************************

Synopsis
========

  * Usage:
        d = numgensByCodim(I,k)
        L = numgensByCodim(I)
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
      * k, an integer (Macaulay2Doc), an integer between 1 and the
        dimension of the ring
  * Outputs:
      * d, an integer (Macaulay2Doc), the maximum number of
        generators of I localized at a prime P of codimension k.
      * L, a list (Macaulay2Doc), a list of the numbers of
        generators for each codimension from 1 to the dimension of the ring

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

Because I is monomial, we can check the number of generators of I localized at
a prime P over only monomial primes P.

+-----------------------------------------------+
|i1 : R = QQ[x_0..x_4];                         |
+-----------------------------------------------+
|i2 : I = monomialIdeal{x_0^2,x_1*x_2,x_3*x_4^2}|
|                                               |
|                     2           2             |
|o2 = monomialIdeal (x , x x , x x )            |
|                     0   1 2   3 4             |
|                                               |
|o2 : MonomialIdeal of R                        |
+-----------------------------------------------+
|i3 : numgensByCodim(I,2)                       |
|                                               |
|o3 = 1                                         |
+-----------------------------------------------+
|i4 : numgensByCodim I                          |
|                                               |
|o4 = {1, 1, 3, 3, 3}                           |
|                                               |
|o4 : List                                      |
+-----------------------------------------------+

See also
========

  * residualCodims -- a list of possible residual
    intersection codimensions
  * maxGs -- maximum G_s of a monomial ideal

Ways to use numgensByCodim :
============================

  * "numgensByCodim(MonomialIdeal)"
  * "numgensByCodim(MonomialIdeal,ZZ)"

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

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

residualCodims -- a list of possible residual intersection codimensions
***********************************************************************

Synopsis
========

  * Usage:
        L = residualCodims I
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), a list of integers s such that I
        localized at any prime of codimension s-1 in the ambient ring has at
        most s generators. The range of values is from codim I + 1 to the
        dimension of the ring + 1.

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

For each s computes the maximum, over all monomial primes P with codimension
s-1 in the ambient ring, of the minimal size of a generating set of I localized
at P.  If this number is less than s, then s is included in the list.

The values s returned are the numbers such that an s-residual intersection of I
exists.

+---------------------------------+
|i1 : R = ZZ/101[a,b,c];          |
+---------------------------------+
|i2 : I = monomialIdeal{a*b,b*c^2}|
|                                 |
|                            2    |
|o2 = monomialIdeal (a*b, b*c )   |
|                                 |
|o2 : MonomialIdeal of R          |
+---------------------------------+
|i3 : residualCodims I            |
|                                 |
|o3 = {2, 3, 4}                   |
|                                 |
|o3 : List                        |
+---------------------------------+

See also
========

  * numgensByCodim -- maximum number of generators of
    localizations of a monomial ideal
  * maxGs -- maximum G_s of a monomial ideal

Ways to use residualCodims :
============================

  * "residualCodims(MonomialIdeal)"

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

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

UseNormalModule -- option for linkageBound and isLicci
******************************************************

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

Default value is false. When true, it enables a more refined computation of the
bound on the number of general links of an ideal I that must be taken to
definitively test the licci property. When UseNormalModule == true the
computation of the normal module Hom(I, (ring I)/I) is required and this can be
slow; if UseNormalModule == false the computation is fast, but the bound is
large.

See also
========

  * isLicci -- Tests whether an ideal is licci
  * linkageBound -- computes a bound on the number of
    general links of an ideal to test the licci property

Functions with optional argument named UseNormalModule :
========================================================

  * "isLicci(...,UseNormalModule=>...)"
  * "linkageBound(...,UseNormalModule=>...)"

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

The object UseNormalModule, is a symbol (Macaulay2Doc).