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

LexIdeals -- a package for working with lex ideals
**************************************************

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

LexIdeals is a package for creating lexicographic ideals and lex-plus-powers
(LPP) ideals.  There are also several functions for use with the multiplicity
conjectures of Herzog, Huneke, and Srinivasan.

Author
======

  * Chris Francisco (see http://www.math.okstate.edu/~chris )
    <chris@math.okstate.edu>

Version
=======

This documentation describes version 1.2 of LexIdeals, released 13 October
2008.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{LexIdealsSource,                                                      |
|  title = {{LexIdeals: lexicographic-type monomial ideals. Version~1.2}},   |
|  author = {Chris Francisco},                                               |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * cancelAll -- make all potentially possible
        cancellations in the graded free resolution of an ideal
      * generateLPPs -- return all LPP ideals
        corresponding to a given Hilbert function
      * hilbertFunct -- return the Hilbert function of a
        polynomial ring mod a homogeneous ideal as a list
      * isCM -- test whether a polynomial ring modulo a
        homogeneous ideal is Cohen-Macaulay
      * isHF -- is a finite list a Hilbert function of a
        polynomial ring mod a homogeneous ideal
      * isLexIdeal -- determine whether an ideal is a
        lexicographic ideal
      * isLPP -- determine whether an ideal is an LPP ideal
      * isPurePower -- determine whether a ring element is
        a pure power of a variable
      * lexIdeal -- produce a lexicographic ideal
      * LPP -- return the lex-plus-powers (LPP) ideal corresponding
        to a given Hilbert function and power sequence
      * macaulayBound -- the bound on the growth of a
        Hilbert function from Macaulay's Theorem
      * macaulayLowerOperator -- the a_<d>
        operator used in Green's proof of Macaulay's Theorem
      * macaulayRep -- the Macaulay representation of an
        integer
      * multBounds -- determine whether an ideal satisfies
        the upper and lower bounds of the multiplicity conjecture
      * multLowerBound -- determine whether an ideal
        satisfies the lower bound of the multiplicity conjecture
      * multUpperBound -- determine whether an ideal
        satisfies the upper bound of the multiplicity conjecture
      * multUpperHF -- test a sufficient condition for the
        upper bound of the multiplicity conjecture
  * Methods
      * "cancelAll(Ideal)" -- see cancelAll, -- make all
        potentially possible cancellations in the graded free resolution of an
        ideal
      * "generateLPPs(PolynomialRing,List)" -- see generateLPPs,
        -- return all LPP ideals corresponding to a given Hilbert
        function
      * "hilbertFunct(Ideal)" -- see hilbertFunct, --
        return the Hilbert function of a polynomial ring mod a homogeneous
        ideal as a list
      * "isCM(Ideal)" -- see isCM, -- test whether a polynomial
        ring modulo a homogeneous ideal is Cohen-Macaulay
      * "isHF(List)" -- see isHF, -- is a finite list a Hilbert
        function of a polynomial ring mod a homogeneous ideal
      * "isLexIdeal(Ideal)" -- see isLexIdeal, -- determine
        whether an ideal is a lexicographic ideal
      * "isLPP(Ideal)" -- see isLPP, -- determine whether an ideal
        is an LPP ideal
      * "isPurePower(RingElement)" -- see isPurePower, --
        determine whether a ring element is a pure power of a variable
      * "lexIdeal(Ideal)" -- see lexIdeal, -- produce a
        lexicographic ideal
      * "lexIdeal(PolynomialRing,List)" -- see lexIdeal, --
        produce a lexicographic ideal
      * "lexIdeal(QuotientRing,List)" -- see lexIdeal, --
        produce a lexicographic ideal
      * "LPP(PolynomialRing,List,List)" -- see LPP, -- return the
        lex-plus-powers (LPP) ideal corresponding to a given Hilbert function
        and power sequence
      * "macaulayBound(ZZ,ZZ)" -- see macaulayBound, --
        the bound on the growth of a Hilbert function from Macaulay's Theorem
      * "macaulayLowerOperator(ZZ,ZZ)" -- see macaulayLowerOperator,
        -- the a_<d> operator used in Green's proof of
        Macaulay's Theorem
      * "macaulayRep(ZZ,ZZ)" -- see macaulayRep, -- the
        Macaulay representation of an integer
      * "multBounds(Ideal)" -- see multBounds, -- determine
        whether an ideal satisfies the upper and lower bounds of the
        multiplicity conjecture
      * "multLowerBound(Ideal)" -- see multLowerBound, --
        determine whether an ideal satisfies the lower bound of the
        multiplicity conjecture
      * "multUpperBound(Ideal)" -- see multUpperBound, --
        determine whether an ideal satisfies the upper bound of the
        multiplicity conjecture
      * "multUpperHF(PolynomialRing,List)" -- see multUpperHF,
        -- test a sufficient condition for the upper bound of the
        multiplicity conjecture
  * Symbols
      * MaxDegree -- optional argument for hilbertFunct
      * PrintIdeals -- optional argument for generateLPPs

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

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

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

The source of this document is in LexIdeals.m2:523:0.

cancelAll -- make all potentially possible cancellations in the graded free resolution of an ideal
**************************************************************************************************

  * Usage:
        l=cancelAll I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring
  * Outputs:
      * l, a list (Macaulay2Doc), lists of the new shifts in the
        Betti diagram

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

This function was useful in testing the upper bound of the conjecture of
Herzog-Huneke-Srinivasan on the multiplicity of an ideal; it is designed to
make all potentially possible cancellations in a Betti diagram in a certain
order described below.

Let R be a polynomial ring, let I and J be homogeneous ideals in R of
codimension c with the same Hilbert function, and assume that R/I and R/J are
Cohen-Macaulay. Suppose that the graded Betti numbers of R/I are at most those
of R/J; that is, beta_{ij}(R/I) <= beta_{ij}(R/J) for all i and j. (We can form
a partial order on resolutions of modules with the same Hilbert function by
saying that beta(R/I) <= beta(R/J) if and only if beta_{ij}(R/I) <=
beta_{ij}(R/J) for all i and j.)

Let m_i(R/I) and M_i(R/I) be the minimum and maximum shifts at step i in the
minimal graded free resolution of R/I. Let e(R/I) be the multiplicity of R/I.
Herzog, Huneke, and Srinivasan conjectured that

m_1(R/I) ... m_c(R/I) / c! <= e(R/I) <= M_1(R/I) ... M_c(R/I) / c!,

where the ellipses signify that we are taking the product of the shifts. This
conjecture was proven in 2008 work of Eisenbud-Schreyer and Boij-Soderberg
using decompositions of Betti diagrams as positive linear combinations of Betti
diagrams of modules with pure resolutions.

Suppose that R/I satisfies the conjectured inequalities. Then it is easy to
show that R/J must as well: Since the resolution of R/J contains all the shifts
in the resolution of R/I plus possibly more, the minimum shifts for R/J can
only be the same or lower, and the maximum shifts can only be the same or
higher. Therefore one can attack this conjecture by looking at resolutions
minimal in the partial order discussed above.

It is difficult to find which potential resolutions at the bottom of the
partial order for a given Hilbert function do occur for a module, however. The
function cancelAll implements a fast way of proving that the upper bound of the
Herzog-Huneke-Srinivasan conjecture is satisfied for particular Hilbert
functions; it is used in multUpperHF. The idea is to create
a Betti diagram that is minimal in the partial order that may or may not
actually occur for a module; we can then test the upper bound on that potential
resolution. As we explain below, if the inequality holds, it doesn't matter
whether the Betti diagram occurs for a module or not.

cancelAll starts with the far left side of the Betti diagram of the ideal I the
user inputs, and it makes all potentially possible cancellations in the first
two columns. Then it moves to the first and second syzygies columns and makes
all potentially possible cancellations, continuing through the rest of the
Betti diagram. This technique is designed to investigate the upper bound of the
conjecture. One may have choices of which syzygies to cancel from the
resolution of the lexicographic ideal. This algorithm selects the cancellations
that, if we start out with a lexicographic ideal L, and R/L is Cohen-Macaulay,
minimize each M_i that could occur for a Cohen-Macaulay module with the same
Hilbert function as R/L. Therefore if the upper bound of the conjecture holds
for the potential Betti diagram that cancelAll produces, it holds for all
Cohen-Macaulay modules with the same Hilbert function and codimension. Even if
the potential Betti diagram cancelAll produces doesn't occur for a module, the
maximum shifts could only increase, which won't cause the inequality to fail if
it holds for the result of cancelAll.

cancelAll makes all the cancellations with the process described above, prints
the resulting Betti diagram, and then returns the shifts in a list of lists.

See C. Francisco, New approaches to bounding the multiplicity of an ideal, J.
Algebra 299 (2006), no. 1, 309-328.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : L=lexIdeal(R,{1,3,6,9,9,6,2});                                          |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : betti res L                                                             |
|                                                                             |
|            0  1  2  3                                                       |
|o3 = total: 1 16 27 12                                                       |
|         0: 1  .  .  .                                                       |
|         1: .  .  .  .                                                       |
|         2: .  1  .  .                                                       |
|         3: .  3  5  2                                                       |
|         4: .  5  9  4                                                       |
|         5: .  5  9  4                                                       |
|         6: .  2  4  2                                                       |
|                                                                             |
|o3 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i4 : cancelAll L                                                             |
|                                                                             |
|total: 1 4 5 2                                                               |
|    0: 1 . . .                                                               |
|    1: . . . .                                                               |
|    2: . 1 . .                                                               |
|    3: . 3 . .                                                               |
|    4: . . 2 .                                                               |
|    5: . . 3 .                                                               |
|    6: . . . 2                                                               |
|                                                                             |
|o4 = {{3, 4, 4, 4}, {6, 6, 7, 7, 7}, {9, 9}}                                 |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : M=lexIdeal(R,{1,3,4,3,2});                                              |
|                                                                             |
|o5 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i6 : betti res M                                                             |
|                                                                             |
|            0 1  2 3                                                         |
|o6 = total: 1 7 10 4                                                         |
|         0: 1 .  . .                                                         |
|         1: . 2  1 .                                                         |
|         2: . 2  3 1                                                         |
|         3: . 1  2 1                                                         |
|         4: . 2  4 2                                                         |
|                                                                             |
|o6 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i7 : cancelAll M                                                             |
|                                                                             |
|total: 1 3 5 3                                                               |
|    0: 1 . . .                                                               |
|    1: . 2 . .                                                               |
|    2: . 1 2 1                                                               |
|    3: . . . .                                                               |
|    4: . . 3 2                                                               |
|                                                                             |
|o7 = {{2, 2, 3}, {4, 4, 6, 6, 6}, {5, 7, 7}}                                 |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : A=ZZ/32003[a..e];                                                       |
+-----------------------------------------------------------------------------+
|i9 : J=lexIdeal(A,{1,5,12,10,6,3})                                           |
|                                                                             |
|                       2     2     2                        2      2     2   |
|o9 = ideal (a*c, a*b, a , b*e , a*e , b*d*e, a*d*e, b*c*e, b e, b*d , a*d ,  |
|     ------------------------------------------------------------------------|
|             2      2   2    3       2   2 2     2    2      3      3   2 2  |
|     b*c*d, b d, b*c , b c, b , c*d*e , c e , c*d e, c d*e, c e, c*d , c d , |
|     ------------------------------------------------------------------------|
|      3    4     4   3 2   4    5   6     5   2 4                            |
|     c d, c , c*e , d e , d e, d , e , d*e , d e )                           |
|                                                                             |
|o9 : Ideal of A                                                              |
+-----------------------------------------------------------------------------+
|i10 : betti res J                                                            |
|                                                                             |
|             0  1   2   3  4  5                                              |
|o10 = total: 1 32 102 130 76 17                                              |
|          0: 1  .   .   .  .  .                                              |
|          1: .  3   3   1  .  .                                              |
|          2: . 13  41  50 28  6                                              |
|          3: .  9  31  40 23  5                                              |
|          4: .  4  15  21 13  3                                              |
|          5: .  3  12  18 12  3                                              |
|                                                                             |
|o10 : BettiTally                                                             |
+-----------------------------------------------------------------------------+
|i11 : cancelAll J                                                            |
|                                                                             |
|total: 1 13 31 28 17 8                                                       |
|    0: 1  .  .  .  . .                                                       |
|    1: .  3  .  .  . .                                                       |
|    2: . 10 31 23  . .                                                       |
|    3: .  .  .  .  8 5                                                       |
|    4: .  .  .  .  . .                                                       |
|    5: .  .  .  5  9 3                                                       |
|                                                                             |
|o11 = {{2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, {4, 4, 4, 4, 4, 4, 4, 4, 4,  |
|      -----------------------------------------------------------------------|
|      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}, {5, |
|      -----------------------------------------------------------------------|
|      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 8, 8,|
|      -----------------------------------------------------------------------|
|      8, 8, 8}, {7, 7, 7, 7, 7, 7, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9}, {8, 8,  |
|      -----------------------------------------------------------------------|
|      8, 8, 8, 10, 10, 10}}                                                  |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * multUpperHF -- test a sufficient condition for the
    upper bound of the multiplicity conjecture
  * multUpperBound -- determine whether an ideal
    satisfies the upper bound of the multiplicity conjecture
  * multLowerBound -- determine whether an ideal
    satisfies the lower bound of the multiplicity conjecture
  * multBounds -- determine whether an ideal satisfies the
    upper and lower bounds of the multiplicity conjecture

Ways to use cancelAll:
======================

  * "cancelAll(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:1030:0.

generateLPPs -- return all LPP ideals corresponding to a given Hilbert function
*******************************************************************************

  * Usage:
        li=generateLPPs(R,hilb)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * hilb, a list (Macaulay2Doc), a Hilbert function as a list
  * Optional inputs (Macaulay2Doc),:
      * PrintIdeals,
        => ..., default value false, print LPP ideals nicely on the screen
  * Outputs:
      * li, a list (Macaulay2Doc), a list of the form {{powers, LPP
        ideal}, {powers, LPP ideal}, ...}

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

Given a polynomial ring R and a Hilbert function hilb for R modulo a
homogeneous ideal, generateLPPs generates all the LPP ideals corresponding to
hilb. The power sequences and ideals are returned in a list. If the user sets
the PrintIdeals option to true, the power sequences and ideals are printed on
the screen in a nice format.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : generateLPPs(R,{1,3,4,3,2})                                             |
|                                                                             |
|                          2   2   4                               2   2   5  |
|o2 = {{{2, 2, 4}, ideal (a , b , c , a*b*c)}, {{2, 2, 5}, ideal (a , b , c , |
|     ------------------------------------------------------------------------|
|               3     4                        2   3   4          2   2 3     |
|     a*b*c, a*c , b*c )}, {{2, 3, 4}, ideal (a , b , c , a*b, a*c , b c )},  |
|     ------------------------------------------------------------------------|
|                         2   3   5          2   2 2     4                    |
|     {{2, 3, 5}, ideal (a , b , c , a*b, a*c , b c , b*c )}}                 |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Same example with the PrintIdeals option set to true:

+-----------------------------------------------------------------------------+
|i3 : generateLPPs(R,{1,3,4,3,2},PrintIdeals=>true)                           |
|                  2   2   4                                                  |
|{2, 2, 4} ideal (a , b , c , a*b*c)                                          |
|                  2   2   5            3     4                               |
|{2, 2, 5} ideal (a , b , c , a*b*c, a*c , b*c )                              |
|                  2   3   4          2   2 3                                 |
|{2, 3, 4} ideal (a , b , c , a*b, a*c , b c )                                |
|                  2   3   5          2   2 2     4                           |
|{2, 3, 5} ideal (a , b , c , a*b, a*c , b c , b*c )                          |
|                                                                             |
|                          2   2   4                               2   2   5  |
|o3 = {{{2, 2, 4}, ideal (a , b , c , a*b*c)}, {{2, 2, 5}, ideal (a , b , c , |
|     ------------------------------------------------------------------------|
|               3     4                        2   3   4          2   2 3     |
|     a*b*c, a*c , b*c )}, {{2, 3, 4}, ideal (a , b , c , a*b, a*c , b c )},  |
|     ------------------------------------------------------------------------|
|                         2   3   5          2   2 2     4                    |
|     {{2, 3, 5}, ideal (a , b , c , a*b, a*c , b c , b*c )}}                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * LPP -- return the lex-plus-powers (LPP) ideal corresponding to
    a given Hilbert function and power sequence
  * isLPP -- determine whether an ideal is an LPP ideal

Ways to use generateLPPs:
=========================

  * "generateLPPs(PolynomialRing,List)"

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

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

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

The source of this document is in LexIdeals.m2:915:0.

generateLPPs(...,PrintIdeals=>...) -- print LPP ideals nicely on the screen
***************************************************************************

  * Usage:
        li = generateLPPs(R,hilb,PrintIdeals=>true)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), the ring in
        which to work
      * hilb, a list (Macaulay2Doc), the values of the Hilbert
        function as a list
  * Outputs:
      * li, a list (Macaulay2Doc), the LPP ideals with Hilbert
        function hilb

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

The default value is false. If PrintIdeals is set to true, the power sequences
and ideals are printed nicely on the screen to make them more readable than
they are in list form.

See also
========

  * generateLPPs -- return all LPP ideals corresponding to
    a given Hilbert function

Functions with optional argument named PrintIdeals:
===================================================

  * generateLPPs(...,PrintIdeals=>...)
    -- print LPP ideals
    nicely on the screen

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

  * Default value: false (Macaulay2Doc),
  * Function: generateLPPs, -- return all LPP ideals
    corresponding to a given Hilbert function
  * Option key: PrintIdeals, -- optional argument for
    generateLPPs
-------------------------------------------------------------------------------

The source of this document is in LexIdeals.m2:1247:0.

hilbertFunct -- return the Hilbert function of a polynomial ring mod a homogeneous ideal as a list
**************************************************************************************************

  * Usage:
        L=hilbertFunct I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring or a quotient of a polynomial ring (where the ring has
        the standard grading)
  * Optional inputs (Macaulay2Doc),:
      * MaxDegree, =>
        ..., default value null, bound degree through which Hilbert function is
        computed
  * Outputs:
      * L, a list (Macaulay2Doc), returns the Hilbert function of
        (ring I)/I as a list

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

Let I be a homogeneous ideal in a ring R that is either a polynomial ring or a
quotient of a polynomial ring, and suppose that R has the standard grading.
hilbertFunct returns the Hilbert function of R/I as a list.

If R/I is Artinian, then the default is for hilbertFunct to return the entire
Hilbert function (i.e., until the Hilbert function is zero) of R/I as a list.
The user can override this by using the MaxDegree option to bound the highest
degree considered.

If R/I is not Artinian, then hilbertFunct returns the Hilbert function of R/I
through degree 20. Again, the user can select a different upper bound for the
degree by using the MaxDegree option.

We require the standard grading on R in order to compute with the Hilbert
series, which is presently much faster than repeatedly computing the Hilbert
function.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : hilbertFunct ideal(a^3,b^3,c^3)                                         |
|                                                                             |
|o2 = {1, 3, 6, 7, 6, 3, 1}                                                   |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : hilbertFunct ideal(a^3,a*b^2)                                           |
|                                                                             |
|o3 = {1, 3, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, |
|     ------------------------------------------------------------------------|
|     24, 25}                                                                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : hilbertFunct(ideal(a^3,a*b^2),MaxDegree=>4)                             |
|                                                                             |
|o4 = {1, 3, 6, 8, 9}                                                         |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : M=ideal(a^3,b^4,a*c);                                                   |
|                                                                             |
|o5 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i6 : Q=R/M;                                                                  |
+-----------------------------------------------------------------------------+
|i7 : hilbertFunct ideal(c^4)                                                 |
|                                                                             |
|o7 = {1, 3, 5, 6, 5, 3, 1}                                                   |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : hilbertFunct ideal(b*c,a*b)                                             |
|                                                                             |
|o8 = {1, 3, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}         |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * isHF -- is a finite list a Hilbert function of a polynomial
    ring mod a homogeneous ideal
  * lexIdeal -- produce a lexicographic ideal

Ways to use hilbertFunct:
=========================

  * "hilbertFunct(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:697:0.

hilbertFunct(...,MaxDegree=>...) -- bound degree through which Hilbert function is computed
*******************************************************************************************

  * Usage:
        li = hilbertFunct(I,MaxDegree=>d)
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal
      * d, an integer (Macaulay2Doc), the highest degree in which the
        Hilbert function should be computed
  * Outputs:
      * li, a list (Macaulay2Doc), the values of the Hilbert
        function through degree d

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

If I is Artinian, the default is to return all values of the Hilbert function
until it becomes zero. If not, the default maximum degree is 20. This option
allows one to specify any maximum degree.

See also
========

  * hilbertFunct -- return the Hilbert function of a
    polynomial ring mod a homogeneous ideal as a list

Functions with optional argument named MaxDegree:
=================================================

  * hilbertFunct(...,MaxDegree=>...)
    -- bound degree through
    which Hilbert function is computed

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

  * Default value: null
  * Function: hilbertFunct, -- return the Hilbert function
    of a polynomial ring mod a homogeneous ideal as a list
  * Option key: MaxDegree, -- optional argument for
    hilbertFunct
-------------------------------------------------------------------------------

The source of this document is in LexIdeals.m2:1288:0.

isCM -- test whether a polynomial ring modulo a homogeneous ideal is Cohen-Macaulay
***********************************************************************************

  * Usage:
        B=isCM I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if (ring I)/I is
        Cohen-Macaulay and false otherwise

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

isCM takes a homogeneous ideal I in a polynomial ring R and, by computing the
projective dimension and codimension of I, determines whether R/I is
Cohen-Macaulay. Of course, isCM works only if Macaulay 2 can compute the
projective dimension of I.

+-------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                           |
+-------------------------------------------------+
|i2 : isCM(ideal(a^2,b^4)) --complete intersection|
|                                                 |
|o2 = true                                        |
+-------------------------------------------------+
|i3 : isCM(ideal(a^3,b^5,c^4,a*c^3)) --Artinian   |
|                                                 |
|o3 = true                                        |
+-------------------------------------------------+
|i4 : isCM(ideal(a^3,a*b^2))                      |
|                                                 |
|o4 = false                                       |
+-------------------------------------------------+

Ways to use isCM:
=================

  * "isCM(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:723:0.

isHF -- is a finite list a Hilbert function of a polynomial ring mod a homogeneous ideal
****************************************************************************************

  * Usage:
        b=isHF L
  * Inputs:
      * L, a list (Macaulay2Doc), a finite list of integers
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), true if L is a
        Hilbert function of a polynomial ring modulo a homogeneous ideal and
        false otherwise

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

Macaulay's Theorem characterizes the sequences of integers that occur as the
Hilbert function of a polynomial ring modulo a homogeneous ideal. isHF checks
that the input is a list of integers and that the first entry of the list is 1,
and then it checks Macaulay's bound in each degree, using macaulayBound.
The function returns true if the sequence of numbers in the
list satisfies the conditions of Macaulay's Theorem and false otherwise.

+-----------------------------------------------------------+
|i1 : isHF({1,3,6,7,5,3})                                   |
|                                                           |
|o1 = true                                                  |
+-----------------------------------------------------------+
|i2 : isHF({2,3,4,3,2}) --doesn't start with a 1 in degree 0|
|                                                           |
|o2 = false                                                 |
+-----------------------------------------------------------+
|i3 : isHF({1,3,6,8,14,3}) --growth from 8 to 14 is too high|
|                                                           |
|o3 = false                                                 |
+-----------------------------------------------------------+

See also
========

  * macaulayRep -- the Macaulay representation of an
    integer
  * macaulayBound -- the bound on the growth of a Hilbert
    function from Macaulay's Theorem

Ways to use isHF:
=================

  * "isHF(List)"

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

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

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

The source of this document is in LexIdeals.m2:653:0.

isLexIdeal -- determine whether an ideal is a lexicographic ideal
*****************************************************************

  * Usage:
        B=isLexIdeal I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring or quotient of a polynomial ring by a homogeneous ideal
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if I is a
        lexicographic ideal in ring I and false otherwise

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

Given an ideal I in a ring R that is either a polynomial ring or a quotient of
a polynomial ring by a monomial ideal, isLexIdeal computes bases of I in each
degree up through the maximum degree of a minimal generator of I to determine
whether I is a lexicographic ideal in R.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : isLexIdeal lexIdeal(R,{1,3,4,3,1})                                      |
|                                                                             |
|o2 = true                                                                    |
+-----------------------------------------------------------------------------+
|i3 : isLexIdeal ideal(a^3-a^2*b)                                             |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+
|i4 : isLexIdeal ideal(a^3,a^2*b)                                             |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+
|i5 : isLexIdeal ideal(a^3,a^2*b,a^3-a^2*b) --not given as a monomial ideal   |
|                                                                             |
|o5 = true                                                                    |
|-----------------------------------------------------------------------------|
|but still a lex ideal                                                        |
+-----------------------------------------------------------------------------+
|i6 : Q=R/ideal(a^3,b^3,a*c^2);                                               |
+-----------------------------------------------------------------------------+
|i7 : isLexIdeal ideal(a^2*b,a^2*c)                                           |
|                                                                             |
|o7 = true                                                                    |
+-----------------------------------------------------------------------------+
|i8 : isLexIdeal ideal(a^2*b,a*b^2)                                           |
|                                                                             |
|o8 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * lexIdeal -- produce a lexicographic ideal

Ways to use isLexIdeal:
=======================

  * "isLexIdeal(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:809:0.

isLPP -- determine whether an ideal is an LPP ideal
***************************************************

  * Usage:
        B=isLPP I
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal in a polynomial ring
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if I is an LPP
        ideal in ring I and false otherwise

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

Given an ideal I in a polynomial ring R, isLPP checks that I is Artinian and
that the power sequence is weakly increasing. Then isLPP computes bases of R/I
in each degree up through the maximum degree of a minimal generator of I to
determine whether I is an LPP ideal in R.

+------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                      |
+------------------------------------------------------------+
|i2 : isLPP LPP(R,{1,3,4,3,2},{2,2,4})                       |
|                                                            |
|o2 = true                                                   |
+------------------------------------------------------------+
|i3 : isLPP ideal(a^3,b^3,c^3,a^2*b,a^2*c,a*b^2*c^2)         |
|                                                            |
|o3 = true                                                   |
+------------------------------------------------------------+
|i4 : isLPP ideal(a^3,b^4) --not Artinian since no power of c|
|                                                            |
|o4 = false                                                  |
+------------------------------------------------------------+
|i5 : isLPP ideal(a^3,b^4,c^3) --powers not weakly increasing|
|                                                            |
|o5 = false                                                  |
+------------------------------------------------------------+
|i6 : isLPP ideal(a^3,b^3,c^3,a^2*b,a*b^2)                   |
|                                                            |
|o6 = false                                                  |
+------------------------------------------------------------+

See also
========

  * isLexIdeal -- determine whether an ideal is a
    lexicographic ideal
  * LPP -- return the lex-plus-powers (LPP) ideal corresponding to
    a given Hilbert function and power sequence
  * generateLPPs -- return all LPP ideals corresponding to
    a given Hilbert function

Ways to use isLPP:
==================

  * "isLPP(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:947:0.

isPurePower -- determine whether a ring element is a pure power of a variable
*****************************************************************************

  * Usage:
        B=isPurePower f
  * Inputs:
      * f, a ring element (Macaulay2Doc), an element of a
        polynomial ring
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if f is a
        nonzero power of a variable and false otherwise

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

isPurePower tests a ring element in a polynomial ring to determine whether or
not it is nonzero and a power of a variable. isPurePower is used in the
lex-plus-powers LPP, code.

+--------------------------+
|i1 : R=ZZ/32003[a..c];    |
+--------------------------+
|i2 : isPurePower a^4      |
|                          |
|o2 = true                 |
+--------------------------+
|i3 : isPurePower (a*b^5)  |
|                          |
|o3 = false                |
+--------------------------+
|i4 : isPurePower (a^3-b^3)|
|                          |
|o4 = false                |
+--------------------------+

See also
========

  * LPP -- return the lex-plus-powers (LPP) ideal corresponding to
    a given Hilbert function and power sequence
  * isLPP -- determine whether an ideal is an LPP ideal

Ways to use isPurePower:
========================

  * "isPurePower(RingElement)"

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

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

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

The source of this document is in LexIdeals.m2:837:0.

lexIdeal -- produce a lexicographic ideal
*****************************************

  * Usage:
        L=lexIdeal(R,hilb) or L=lexIdeal(Q,hilb) or L=lexIdeal(I)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * Q, a quotient ring (Macaulay2Doc), a polynomial
        ring modulo a homogeneous ideal
      * hilb, a list (Macaulay2Doc), a finite length list of
        positive integers
      * I, an ideal (Macaulay2Doc), a homogeneous ideal
  * Outputs:
      * L, an ideal (Macaulay2Doc), the Artinian lexicographic
        ideal L in R (resp. Q) such that R/L (resp. Q/L) has Hilbert function
        hilb OR the lexicographic ideal (possibly not Artinian) L in R or Q
        with the same Hilbert function as I

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

When R is a polynomial ring, if hilb is an O-sequence (that is, it satisfies
Macaulay's Theorem), such an L always exists. When Q is a quotient of a
polynomial ring, there may be no lexicographic ideal with a particular Hilbert
function even if it is an O-sequence. lexIdeal returns null if no lexicographic
ideal L corresponding to the Hilbert function hilb exists in R or Q.

When lexIdeal has an ideal as its input, it returns the lexicographic ideal
with the same Hilbert function as its output. If no such ideal exists, which
may happen since Macaulay's Theorem fails in some quotient rings, then lexIdeal
returns null.

The function now works for quotients by arbitrary homogeneous ideals, not just
monomial ideals. We thank David Eisenbud and Jeff Mermin for contributing their
ideas.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : lexIdeal(R,{1,3,4,3,1})                                                 |
|                                                                             |
|                  2     2   3     3   2 2   5                                |
|o2 = ideal (a*b, a , a*c , b , b*c , b c , c )                               |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : lexIdeal ideal(a*b,b*c)                                                 |
|                                                                             |
|                  2                                                          |
|o3 = ideal (a*b, a )                                                         |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : lexIdeal(R,{1,3,7}) --not an O-sequence, so no lex ideal exists         |
+-----------------------------------------------------------------------------+
|i5 : Q=R/ideal(a^3,b^3,a*c^2);                                               |
+-----------------------------------------------------------------------------+
|i6 : lexIdeal(Q,{1,3,6,4,2})                                                 |
|                                                                             |
|             2      2   2    2 2   5     4                                   |
|o6 = ideal (a c, a*b , a b, b c , c , b*c )                                  |
|                                                                             |
|o6 : Ideal of Q                                                              |
+-----------------------------------------------------------------------------+
|i7 : lexIdeal(Q,{1,3,6,4,4}) --value of 4 in degree 4 is too high in this    |
|-----------------------------------------------------------------------------|
|ring                                                                         |
+-----------------------------------------------------------------------------+

Caveat
======

Note that we use the Gotzmann Persistence Theorem as a stopping criterion, so
one should make sure this holds in the ring in which one is computing.

See also
========

  * macaulayRep -- the Macaulay representation of an
    integer
  * macaulayBound -- the bound on the growth of a Hilbert
    function from Macaulay's Theorem
  * isHF -- is a finite list a Hilbert function of a polynomial
    ring mod a homogeneous ideal
  * isLexIdeal -- determine whether an ideal is a
    lexicographic ideal

Ways to use lexIdeal:
=====================

  * "lexIdeal(Ideal)"
  * "lexIdeal(PolynomialRing,List)"
  * "lexIdeal(QuotientRing,List)"

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

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

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

The source of this document is in LexIdeals.m2:777:0.

LPP -- return the lex-plus-powers (LPP) ideal corresponding to a given Hilbert function and power sequence
**********************************************************************************************************

  * Usage:
        L=LPP(R,hilb,power)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * hilb, a list (Macaulay2Doc), a Hilbert function as a list
      * power, a list (Macaulay2Doc), a list of positive integers
        in weakly increasing order
  * Outputs:
      * L, an ideal (Macaulay2Doc), an LPP ideal with the desired
        Hilbert function and power sequence if one exists and null otherwise

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

Let a_1 <= ... <= a_n be positive integers. A monomial ideal L in a polynomial
ring R=k[x_1,...,x_n] is called an (a_1,...a_n)-lex-plus-powers (LPP) ideal if
it satisfies two conditions:

(1) L is minimally generated by x_1^{a_1}, ..., x_n^{a_n} and monomials m_1,
..., m_t. (2) Suppose that r is a monomial such that deg r = deg m_i, and r >
m_i in the lex order. Then r is in L.

LPP ideals are generalizations of Artinian lexicographic ideals. Condition (2)
represents the lex portion of the LPP ideal; monomials that are not powers of a
variable must satisfy a lexicographic condition similar to what generators of
lex ideals satisfy. An LPP ideal also contains powers of all the variables in
weakly increasing order.

LPP ideals arise in conjectures of Eisenbud-Green-Harris and Charalambous-Evans
in algebraic geometry, Hilbert functions, and graded free resolutions. They are
conjectured to play a role analogous to that of lexicographic ideals in
theorems of Macaulay on Hilbert functions and Bigatti, Hulett, and Pardue on
resolutions.

+-----------------------------------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : LPP(R,{1,3,6,5,3},{3,3,4})                                              |
|                                                                             |
|             3   3   4   2    2      2       2   2 3                         |
|o2 = ideal (a , b , c , a b, a c, a*b , a*b*c , b c )                        |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : LPP(R,{1,3,4,2,1},{2,3,5}) --an Artinian lex ideal                      |
|                                                                             |
|             2   3   5          2   2      3                                 |
|o3 = ideal (a , b , c , a*b, a*c , b c, b*c )                                |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : LPP(R,{1,3,4,2,1},{2,4,3}) --exponents not in weakly increasing order   |
+-----------------------------------------------------------------------------+
|i5 : LPP(R,{1,3,4,2,1},{2,2,3}) --no LPP ideal with this Hilbert function and|
|-----------------------------------------------------------------------------|
|power sequence                                                               |
+-----------------------------------------------------------------------------+

See also
========

  * generateLPPs -- return all LPP ideals corresponding to
    a given Hilbert function
  * isLPP -- determine whether an ideal is an LPP ideal

Ways to use LPP:
================

  * "LPP(PolynomialRing,List,List)"

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

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

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

The source of this document is in LexIdeals.m2:882:0.

macaulayBound -- the bound on the growth of a Hilbert function from Macaulay's Theorem
**************************************************************************************

  * Usage:
        h=macaulayBound(a,d)
  * Inputs:
      * a, an integer (Macaulay2Doc), a positive integer
      * d, an integer (Macaulay2Doc), a positive integer
  * Outputs:
      * h, an integer (Macaulay2Doc), the Macaulay upper bound for
        the Hilbert function in degree d+1 given that it is a in degree d.

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

Given a Hilbert function of a in degree d, macaulayBound yields the upper bound
from Macaulay's Theorem for the Hilbert function in degree d+1.

+------------------------+
|i1 : macaulayBound(3,1) |
|                        |
|o1 = 6                  |
+------------------------+
|i2 : macaulayBound(15,5)|
|                        |
|o2 = 18                 |
+------------------------+

See also
========

  * macaulayRep -- the Macaulay representation of an
    integer
  * macaulayLowerOperator -- the a_<d> operator
    used in Green's proof of Macaulay's Theorem
  * isHF -- is a finite list a Hilbert function of a polynomial
    ring mod a homogeneous ideal

Ways to use macaulayBound:
==========================

  * "macaulayBound(ZZ,ZZ)"

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

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

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

The source of this document is in LexIdeals.m2:595:0.

macaulayLowerOperator -- the a_<d> operator used in Green's proof of Macaulay's Theorem
***************************************************************************************

  * Usage:
        h=macaulayLowerOperator(a,d)
  * Inputs:
      * a, an integer (Macaulay2Doc), a positive integer
      * d, an integer (Macaulay2Doc), a positive integer
  * Outputs:
      * h, an integer (Macaulay2Doc), a nonnegative integer
        representing a_<d>

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

Given positive integers a and d, macaulayLowerOperator yields a_<d>, the
operation from Green's proof of Macaulay's Theorem. See Bruns and Herzog,
Cohen-Macaulay Rings, page 161.

+--------------------------------+
|i1 : macaulayLowerOperator(3,1) |
|                                |
|o1 = 2                          |
+--------------------------------+
|i2 : macaulayLowerOperator(15,5)|
|                                |
|o2 = 3                          |
+--------------------------------+

See also
========

  * macaulayRep -- the Macaulay representation of an
    integer
  * macaulayBound -- the bound on the growth of a Hilbert
    function from Macaulay's Theorem

Ways to use macaulayLowerOperator:
==================================

  * "macaulayLowerOperator(ZZ,ZZ)"

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

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

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

The source of this document is in LexIdeals.m2:623:0.

macaulayRep -- the Macaulay representation of an integer
********************************************************

  * Usage:
        h=macaulayRep(a,d)
  * Inputs:
      * a, an integer (Macaulay2Doc), a nonnegative integer
      * d, an integer (Macaulay2Doc), a positive integer
  * Outputs:
      * L, a list (Macaulay2Doc), a list of pairs {i,j} of integers
        such that j <= d for all terms, and a is the sum of the binomial(i,j).

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

Yields the d-th Macaulay representation of the integer a. Given a positive
integer d, each positive integer a can be uniquely represented as a sum of
binomials binomial(b_d,d) + binomial(b_{d-1},d-1) + ... + binomial(b_1,1),
where b_d > b_{d-1} > ... > b_1 >= 0.

+---------------------------------------------+
|i1 : macaulayRep(100,4)                      |
|                                             |
|o1 = {{8, 4}, {6, 3}, {5, 2}}                |
|                                             |
|o1 : List                                    |
+---------------------------------------------+
|i2 : macaulayRep(10,5)                       |
|                                             |
|o2 = {{6, 5}, {4, 4}, {3, 3}, {2, 2}, {1, 1}}|
|                                             |
|o2 : List                                    |
+---------------------------------------------+

See also
========

  * macaulayBound -- the bound on the growth of a Hilbert
    function from Macaulay's Theorem
  * isHF -- is a finite list a Hilbert function of a polynomial
    ring mod a homogeneous ideal

Ways to use macaulayRep:
========================

  * "macaulayRep(ZZ,ZZ)"

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

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

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

The source of this document is in LexIdeals.m2:562:0.

MaxDegree -- optional argument for hilbertFunct
***********************************************

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

Used to set the highest degree through which hilbertFunct should compute the
Hilbert function.

See also
========

  * hilbertFunct -- return the Hilbert function of a
    polynomial ring mod a homogeneous ideal as a list

Functions with optional argument named MaxDegree:
=================================================

  * hilbertFunct(...,MaxDegree=>...)
    -- bound degree through
    which Hilbert function is computed

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

The object MaxDegree, is a symbol (Macaulay2Doc).

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

The source of this document is in LexIdeals.m2:1264:0.

multBounds -- determine whether an ideal satisfies the upper and lower bounds of the multiplicity conjecture
************************************************************************************************************

  * Usage:
        B=multBounds I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if both the
        upper and lower bounds hold and false otherwise

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

Let I be a homogeneous ideal of codimension c in a polynomial ring R such that
R/I is Cohen-Macaulay. Herzog, Huneke, and Srinivasan conjectured that if R/I
is Cohen-Macaulay, then

m_1 ... m_c / c! <= e(R/I) <= M_1 ... M_c / c!,

where m_i is the minimum shift in the minimal graded free resolution of R/I at
step i, M_i is the maximum shift in the minimal graded free resolution of R/I
at step i, and e(R/I) is the multiplicity of R/I. If R/I is not Cohen-Macaulay,
the upper bound is still conjectured to hold. multBounds tests the inequalities
for the given ideal, returning true if both inequalities hold and false
otherwise. multBounds prints the bounds and the multiplicity (called the
degree), and it calls multUpperBound, and
multLowerBound.

This conjecture was proven in 2008 work of Eisenbud-Schreyer and
Boij-Soderberg.

+------------------------------------------------------+
|i1 : S=ZZ/32003[a..c];                                |
+------------------------------------------------------+
|i2 : multBounds ideal(a^4,b^4,c^4)                    |
|                                                      |
|lower bound = 64 degree = 64 upper bound = 64         |
|                                                      |
|o2 = true                                             |
+------------------------------------------------------+
|i3 : multBounds ideal(a^3,b^4,c^5,a*b^3,b*c^2,a^2*c^3)|
|                                                      |
|              35                           140        |
|lower bound = -- degree = 27 upper bound = ---        |
|               2                            3         |
|                                                      |
|o3 = true                                             |
+------------------------------------------------------+

Caveat
======

Note that multBounds makes no attempt to check to see whether R/I is
Cohen-Macaulay.

See also
========

  * cancelAll -- make all potentially possible cancellations
    in the graded free resolution of an ideal
  * multUpperHF -- test a sufficient condition for the
    upper bound of the multiplicity conjecture
  * multUpperBound -- determine whether an ideal
    satisfies the upper bound of the multiplicity conjecture
  * multLowerBound -- determine whether an ideal
    satisfies the lower bound of the multiplicity conjecture

Ways to use multBounds:
=======================

  * "multBounds(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:1202:0.

multLowerBound -- determine whether an ideal satisfies the lower bound of the multiplicity conjecture
*****************************************************************************************************

  * Usage:
        B=multLowerBound I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring R
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if I satisfies
        the lower bound and false otherwise

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

Let I be a homogeneous ideal of codimension c in a polynomial ring R such that
R/I is Cohen-Macaulay. Huneke and Srinivasan conjectured that

m_1 ... m_c / c! <= e(R/I),

where m_i is the minimum shift in the minimal graded free resolution of R/I at
step i, and e(R/I) is the multiplicity of R/I. multLowerBound tests this
inequality for the given ideal, returning true if the inequality holds and
false otherwise, and it prints the lower bound and the multiplicity (listed as
the degree).

This conjecture was proven in 2008 work of Eisenbud-Schreyer and
Boij-Soderberg.

+--------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                            |
+--------------------------------------------------+
|i2 : multLowerBound ideal(a^4,b^4,c^4)            |
|                                                  |
|lower bound = 64 degree = 64                      |
|                                                  |
|o2 = true                                         |
+--------------------------------------------------+
|i3 : multLowerBound ideal(a^3,b^5,c^6,a^2*b,a*b*c)|
|                                                  |
|lower bound = 16 degree = 46                      |
|                                                  |
|o3 = true                                         |
+--------------------------------------------------+

Caveat
======

Note that multLowerBound makes no attempt to check to see whether R/I is
Cohen-Macaulay.

See also
========

  * cancelAll -- make all potentially possible cancellations
    in the graded free resolution of an ideal
  * multUpperHF -- test a sufficient condition for the
    upper bound of the multiplicity conjecture
  * multUpperBound -- determine whether an ideal
    satisfies the upper bound of the multiplicity conjecture
  * multBounds -- determine whether an ideal satisfies the
    upper and lower bounds of the multiplicity conjecture

Ways to use multLowerBound:
===========================

  * "multLowerBound(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:1161:0.

multUpperBound -- determine whether an ideal satisfies the upper bound of the multiplicity conjecture
*****************************************************************************************************

  * Usage:
        B=multUpperBound I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a homogeneous ideal in a
        polynomial ring
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if I satisfies
        the upper bound and false otherwise

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

Let I be a homogeneous ideal of codimension c in a polynomial ring R. Huneke
and Srinivasan (and later Herzog and Srinivasan in the non-Cohen-Macaulay case)
conjectured that

e(R/I) <= M_1 ... M_c / c!,

where M_i is the maximum shift in the minimal graded free resolution of R/I at
step i, and e(R/I) is the multiplicity of R/I. multUpperBound tests this
inequality for the given ideal, returning true if the inequality holds and
false otherwise, and it prints the upper bound and the multiplicity (listed as
the degree).

This conjecture was proven in 2008 work of Eisenbud-Schreyer and
Boij-Soderberg.

+--------------------------------------------------+
|i1 : R=ZZ/32003[a..c];                            |
+--------------------------------------------------+
|i2 : multUpperBound ideal(a^4,b^4,c^4)            |
|                                                  |
|degree = 64  upper bound = 64                     |
|                                                  |
|o2 = true                                         |
+--------------------------------------------------+
|i3 : multUpperBound ideal(a^3,b^5,c^6,a^2*b,a*b*c)|
|                                                  |
|degree = 46  upper bound = 132                    |
|                                                  |
|o3 = true                                         |
+--------------------------------------------------+

See also
========

  * cancelAll -- make all potentially possible cancellations
    in the graded free resolution of an ideal
  * multUpperHF -- test a sufficient condition for the
    upper bound of the multiplicity conjecture
  * multLowerBound -- determine whether an ideal
    satisfies the lower bound of the multiplicity conjecture
  * multBounds -- determine whether an ideal satisfies the
    upper and lower bounds of the multiplicity conjecture

Ways to use multUpperBound:
===========================

  * "multUpperBound(Ideal)"

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

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

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

The source of this document is in LexIdeals.m2:1121:0.

multUpperHF -- test a sufficient condition for the upper bound of the multiplicity conjecture
*********************************************************************************************

  * Usage:
        B=multUpperHF(R,hilb)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), the
        polynomial ring in which one wants to work
      * hilb, a list (Macaulay2Doc), a Hilbert function for R
        modulo a homogeneous ideal
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if the
        sufficient condition holds and false otherwise

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

This function uses cancelAll, to test a sufficient condition
for the upper bound of the Herzog-Huneke-Srinivasan conjecture to hold for all
quotients of polynomial rings with Hilbert function hilb. The conjecture,
proven in 2008 work of Eisenbud-Schreyer and Boij-Soderberg, asserts that if R
is a polynomial ring, and I is a homogeneous ideal in R, then

e(R/I) <= M_1 ... M_c / c!,

where M_i is the largest shift at step i of the minimal graded free resolution
of R/I, c is the codimension of I, and e(R/I) is the multiplicity of R/I.

multUpperHF forms the lex ideal corresponding to the Hilbert function the user
inputs. Then it calls cancelAll, to make all potentially
possible cancellations in the resolution of the lex ideal (as described in the
cancelAll, documentation). See cancelAll, prints
the diagram with the cancellations. In addition, multUpperHF compares the
multiplicity associated to the given Hilbert function to the conjectured upper
bound from the Betti diagram with the cancellations. If the conjectured
inequality holds, the function returns true, and the conjectured upper bound is
true for all modules R/I with the given Hilbert function. If the inequality
fails, then the function returns false, and the sufficient condition does not
hold. (However, this of course does not mean that the conjecture is false for
the given Hilbert function; it may be that the Betti diagram with the
cancellations cannot exist.) Note that since hilb is a finite list, all modules
with that Hilbert function are Artinian and hence Cohen-Macaulay.

See C. Francisco, New approaches to bounding the multiplicity of an ideal, J.
Algebra 299 (2006), no. 1, 309-328.

+-----------------------------------------------------------------------------+
|i1 : S=ZZ/32003[a..c];                                                       |
+-----------------------------------------------------------------------------+
|i2 : betti res lexIdeal(S,{1,3,4,2,1}) --just to see the resolution of the   |
|                                                                             |
|            0 1  2 3                                                         |
|o2 = total: 1 7 10 4                                                         |
|         0: 1 .  . .                                                         |
|         1: . 2  1 .                                                         |
|         2: . 3  5 2                                                         |
|         3: . 1  2 1                                                         |
|         4: . 1  2 1                                                         |
|                                                                             |
|o2 : BettiTally                                                              |
|-----------------------------------------------------------------------------|
|lex ideal                                                                    |
+-----------------------------------------------------------------------------+
|i3 : multUpperHF(S,{1,3,4,2,1})                                              |
|                                                                             |
|total: 1 4 5 2                                                               |
|    0: 1 . . .                                                               |
|    1: . 2 . .                                                               |
|    2: . 2 4 1                                                               |
|    3: . . . .                                                               |
|    4: . . 1 1                                                               |
|                                                                             |
|degree = 11  upper bound = 21                                                |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * cancelAll -- make all potentially possible cancellations
    in the graded free resolution of an ideal
  * multUpperBound -- determine whether an ideal
    satisfies the upper bound of the multiplicity conjecture
  * multLowerBound -- determine whether an ideal
    satisfies the lower bound of the multiplicity conjecture
  * multBounds -- determine whether an ideal satisfies the
    upper and lower bounds of the multiplicity conjecture

Ways to use multUpperHF:
========================

  * "multUpperHF(PolynomialRing,List)"

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

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

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

The source of this document is in LexIdeals.m2:1082:0.

PrintIdeals -- optional argument for generateLPPs
*************************************************

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

Tells generateLPPs, to display the LPP ideals nicely on the
screen.

See also
========

  * generateLPPs -- return all LPP ideals corresponding to
    a given Hilbert function

Functions with optional argument named PrintIdeals:
===================================================

  * generateLPPs(...,PrintIdeals=>...)
    -- print LPP ideals
    nicely on the screen

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

The object PrintIdeals, is a symbol (Macaulay2Doc).

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

The source of this document is in LexIdeals.m2:1224:0.