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

MultiplicitySequence -- multiplicity sequence of ideals
*******************************************************

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

The goal of this package is to compute the multiplicity sequence of an ideal
$I$ in a standard graded equidimensional ring over a field $(R,m,k)$, where $m
= R_+$. The multiplicity sequence is a generalization of the Hilbert-Samuel
multiplicity for ideals that are not necessarily m-primary. This sequence is
obtained by considering the second sum transform of the Hilbert polynomial in
two variables of the bigraded ring grGr, which is the associated graded algebra
of the extension of $m$ in the associated graded algebra of $I$.

The multiplicity sequence was defined by Achiles and Manaresi in intersection
theory [AM97]. Its importance comes from applications to problems in
singularity theory (Segre numbers [AR01]) and commutative algebra (numerical
characterization of integral dependence [PTUV20, SH06]). Indeed, in [PTUV20]
the authors show that in a equidimensional and universally catenary Noetherian
local ring, two ideals $J\subset I$ have the same integral closure if and only
if they have the same multiplicity sequence.

This package includes two different ways of computing the multiplicity sequence
of an ideal. The first one uses the definition in terms of Hilbert polynomials,
while the second uses a general element approach based on [AM97] (see also
[PTUV20]). The package also contains a method that computes all of the
coefficients of the Hilbert polynomial of a multi-graded module. These numbers
can be seen as the generalizations of Hilbert coefficients for ideals that are
not necessarily m-primary.

One of the terms of the multiplicity sequence is the j-multiplicity, another
important invariant of an ideal in multiplicity theory. This package also
contains a method jMult which computes the j-multiplicity of an ideal using
Theorem 3.6 in [NU10], based on code written by H. Schenck and J. Validashti.
There is also a method monjMult which computes the j-multiplicity of a monomial
ideal via polyhedral volume computations, using a result of [JM13]. The package
also includes several functions related to integral dependence of monomial
ideals, such as Newton polyhedron, analytic spread, and monomial reductions.

The second author thanks D. Eisenbud, D. Grayson, and M. Stillman for
organizing a Macaulay2 day during the special year in commutative algebra
2012-2013 at MSRI where he learned how to write a package.

References:

  * [AM97] Achilles-Manaresi, Multiplicities of a bigraded ring and
    intersection theory. Math. Ann. 309, 573–591 (1997).
  * [AR01] Achilles-Rams, Intersection numbers, Segre numbers and generalized
    Samuel multiplicities. Arch. Math. (Basel) 77, 391–398 (2001)
  * [JM13] Jeffries-Montaño, The j-multiplicity of monomial ideals, Math. Res.
    Lett. 20 (2013), no. 4, 729–744.
  * [NU10] Nishida-Ulrich, Computing j-multiplicities, J. Pure Appl. Algebra,
    214(12) (2010), 2101–2110.
  * [PTUV20] Polini-Trung-Ulrich-Validashti, Multiplicity sequence and integral
    dependence. Math. Ann. 378 (2020), no. 3-4, 951–969.
  * [SH06] Swanson-Huneke, Integral Closure of Ideals, Rings, and Modules,
    London Mathematical Society Lecture Note Series, vol. 336. Cambridge
    University Press, Cambridge (2006).

Authors
=======

  * Justin Chen <justin.chen@math.gatech.edu>
  * Youngsu Kim <youngsu.kim@csusb.edu>
  * Jonathan Montaño <jmon@nmsu.edu>

Version
=======

This documentation describes version 0.7 of MultiplicitySequence.

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

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

Exports
=======

  * Functions and commands
      * grGr -- the bigraded ring Gr_m(Gr_I(R))
      * hilbertSequence -- the Hilbert sequence of a
        multi-graded module
      * jMult -- the j-multiplicity of an ideal
      * monAnalyticSpread -- the analytic spread of a
        monomial ideal
      * monjMult -- j-multiplicity of a monomial ideal
      * monReduction -- the minimal monomial reduction of
        a monomial ideal
      * multiplicitySequence -- the multiplicity
        sequence of an ideal
      * NP -- the Newton polyhedron of a monomial ideal
      * printHilbertSequence -- prints the Hilbert
        sequence as a table
  * Methods
      * "grGr(Ideal)" -- see grGr, -- the bigraded ring
        Gr_m(Gr_I(R))
      * "grGr(Ideal,Ideal)" -- see grGr, -- the bigraded ring
        Gr_m(Gr_I(R))
      * "hilbertSequence(Ideal)" -- see hilbertSequence,
        -- the Hilbert sequence of a multi-graded module
      * "hilbertSequence(Module)" -- see hilbertSequence,
        -- the Hilbert sequence of a multi-graded module
      * "hilbertSequence(Ring)" -- see hilbertSequence,
        -- the Hilbert sequence of a multi-graded module
      * "jMult(Ideal)" -- see jMult, -- the j-multiplicity of an
        ideal
      * "monAnalyticSpread(Ideal)" -- see monAnalyticSpread,
        -- the analytic spread of a monomial ideal
      * "monjMult(Ideal)" -- see monjMult, -- j-multiplicity of
        a monomial ideal
      * "monReduction(Ideal)" -- see monReduction, -- the
        minimal monomial reduction of a monomial ideal
      * "multiplicitySequence(Ideal)" -- see multiplicitySequence,
        -- the multiplicity sequence of an ideal
      * "multiplicitySequence(ZZ,Ideal)" -- see multiplicitySequence,
        -- the multiplicity sequence of an ideal
      * "NP(Ideal)" -- see NP, -- the Newton polyhedron of a monomial
        ideal
      * "printHilbertSequence(HashTable)" -- see printHilbertSequence,
        -- prints the Hilbert sequence as a table
  * Symbols
      * "DoSaturate" -- see hilbertSequence, -- the
        Hilbert sequence of a multi-graded module
      * "minTerms" -- see multiplicitySequence, --
        the multiplicity sequence of an ideal
      * "numCandidates" -- see multiplicitySequence,
        -- the multiplicity sequence of an ideal

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

The object MultiplicitySequence, is a package (Macaulay2Doc).

grGr -- the bigraded ring Gr_m(Gr_I(R))
***************************************

Synopsis
========

  * Usage:
        grGr(I)
  * Inputs:
      * m, an ideal (Macaulay2Doc), (assumed to be the irrelevant
        ideal of R, if not specified)
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * a ring (Macaulay2Doc), the bigraded ring Gr_m(Gr_I(R))

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

Given a (graded) ideal I in a (graded-)local ring (R,m), this function computes
the bi-graded ring Gr_m(Gr_I(R)), presented as a quotient of a bigraded
polynomial ring with variables names u and v. After being computed once, this
ring is stored in the cache of I. This function is based on the method
normalCone.

+-------------------------------+
|i1 : R = QQ[x,y]               |
|                               |
|o1 = R                         |
|                               |
|o1 : PolynomialRing            |
+-------------------------------+
|i2 : I = ideal"x2,xy"          |
|                               |
|             2                 |
|o2 = ideal (x , x*y)           |
|                               |
|o2 : Ideal of R                |
+-------------------------------+
|i3 : A = grGr I                |
|                               |
|o3 = A                         |
|                               |
|o3 : QuotientRing              |
+-------------------------------+
|i4 : describe A                |
|                               |
|            QQ[u ..v ]         |
|                0   1          |
|o4 = -----------------------   |
|                    2          |
|     (u v  - u v , u , u u )   |
|       0 1    1 0   1   0 1    |
+-------------------------------+
|i5 : hilbertSeries A           |
|                               |
|           2           3    2  |
|     1 - 2T  - T T  + T  + T T |
|           0    0 1    0    0 1|
|o5 = --------------------------|
|                 2        2    |
|         (1 - T ) (1 - T )     |
|               1        0      |
|                               |
|o5 : Expression of class Divide|
+-------------------------------+

See also
========

  * normalCone (ReesAlgebra) -- The normal cone of a
    subscheme

Ways to use grGr :
==================

  * "grGr(Ideal)"
  * "grGr(Ideal,Ideal)"

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

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

hilbertSequence -- the Hilbert sequence of a multi-graded module
****************************************************************

Synopsis
========

  * Usage:
        hilbertSequence M
  * Inputs:
      * M, a module (Macaulay2Doc), or ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * DoSaturate => ..., default value false
  * Outputs:
      * a hash table (Macaulay2Doc), the Hilbert sequence of M

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

Given an $\NN^p$-graded module M, this function computes the coefficients of
the pth sum transform of the $\NN^p$-graded Hilbert function of M in its
Macaulay expansion. If the input is an ideal I, then the Hilbert sequence of
comodule I is returned.

+-----------------------------------------------+
|i1 : R = QQ[a..e, DegreeRank => 5]             |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : I = monomialIdeal "de,abe,ace,abcd"       |
|                                               |
|o2 = monomialIdeal (a*b*c*d, a*b*e, a*c*e, d*e)|
|                                               |
|o2 : MonomialIdeal of R                        |
+-----------------------------------------------+
|i3 : hilbertSequence I                         |
|                                               |
|o3 = HashTable{{0, 0, 0, 0, 1} => -1}          |
|               {0, 0, 0, 1, 0} => 1            |
|               {0, 0, 1, 0, 0} => 1            |
|               {0, 0, 1, 1, 0} => -1           |
|               {0, 1, 0, 0, 0} => 1            |
|               {0, 1, 0, 1, 0} => -1           |
|               {0, 1, 1, 0, 0} => -2           |
|               {0, 1, 1, 0, 1} => 1            |
|               {0, 1, 1, 1, 0} => 1            |
|               {1, 0, 0, 0, 1} => 1            |
|               {1, 0, 0, 1, 0} => -1           |
|               {1, 0, 1, 0, 0} => -1           |
|               {1, 0, 1, 1, 0} => 1            |
|               {1, 1, 0, 0, 0} => -1           |
|               {1, 1, 0, 1, 0} => 1            |
|               {1, 1, 1, 0, 0} => 1            |
|                                               |
|o3 : HashTable                                 |
+-----------------------------------------------+

For singly-graded modules, one can read off the Hilbert polynomial from the
Hilbert sequence:

+-----------------------------------------------+
|i4 : R = QQ[a..e]                              |
|                                               |
|o4 = R                                         |
|                                               |
|o4 : PolynomialRing                            |
+-----------------------------------------------+
|i5 : I = monomialIdeal "de,abe,ace,abcd"       |
|                                               |
|o5 = monomialIdeal (a*b*c*d, a*b*e, a*c*e, d*e)|
|                                               |
|o5 : MonomialIdeal of R                        |
+-----------------------------------------------+
|i6 : hilbertSequence I                         |
|                                               |
|o6 = HashTable{{1} => 2 }                      |
|               {2} => -6                       |
|               {3} => 5                        |
|                                               |
|o6 : HashTable                                 |
+-----------------------------------------------+
|i7 : hilbertPolynomial I                       |
|                                               |
|o7 = 2*P  - 6*P  + 5*P                         |
|        0      1      2                        |
|                                               |
|o7 : ProjectiveHilbertPolynomial               |
+-----------------------------------------------+

A convenient expression for the Hilbert sequence is provided via
printHilbertSequence.

Caveat
======

In general, to retain a connection to the Hilbert polynomial (as opposed to the
pth sum transform) it is necessary to saturate with respect to the irrelevant
ideal, cf. page 235 of Conca-De Negri-Gorla, "Cartwright–Sturmfels ideals
associated to graphs and linear spaces", 2018. This is handled by the optional
argument DoSaturate.

See also
========

  * hilbertPolynomial (Macaulay2Doc) -- compute the
    Hilbert polynomial
  * printHilbertSequence -- prints the Hilbert
    sequence as a table

Ways to use hilbertSequence :
=============================

  * "hilbertSequence(Ideal)"
  * "hilbertSequence(Module)"
  * "hilbertSequence(Ring)"

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

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

jMult -- the j-multiplicity of an ideal
***************************************

Synopsis
========

  * Usage:
        jMult(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * an integer (Macaulay2Doc), the j-multiplicity of I

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

Given an ideal I, this function computes the j-multiplicity of I following the
method of Nishida-Ulrich.

+---------------------------------------+
|i1 : R = QQ[x,y,z]                     |
|                                       |
|o1 = R                                 |
|                                       |
|o1 : PolynomialRing                    |
+---------------------------------------+
|i2 : I = ideal"xy,yz,zx"               |
|                                       |
|o2 = ideal (x*y, y*z, x*z)             |
|                                       |
|o2 : Ideal of R                        |
+---------------------------------------+
|i3 : elapsedTime jMult I               |
| -- 0.0206133 seconds elapsed          |
|                                       |
|o3 = 2                                 |
+---------------------------------------+
|i4 : elapsedTime monjMult I            |
| -- 0.0874663 seconds elapsed          |
|                                       |
|o4 = 2                                 |
+---------------------------------------+
|i5 : elapsedTime multiplicitySequence I|
| -- 0.0958998 seconds elapsed          |
|                                       |
|o5 = HashTable{2 => 3}                 |
|               3 => 2                  |
|                                       |
|o5 : HashTable                         |
+---------------------------------------+

See also
========

  * multiplicitySequence -- the multiplicity
    sequence of an ideal
  * monjMult -- j-multiplicity of a monomial ideal

Ways to use jMult :
===================

  * "jMult(Ideal)"

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

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

monAnalyticSpread -- the analytic spread of a monomial ideal
************************************************************

Synopsis
========

  * Usage:
        monAnalyticSpread(I)
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
  * Outputs:
      * a monomial ideal (Macaulay2Doc), the analytic
        spread of I

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

Given a monomial ideal I, this function computes the analytic spread of I as
one more than the maximal dimension of a bounded facet of its Newton
polyhedron.

+------------------------------------+
|i1 : R = QQ[x,y]                    |
|                                    |
|o1 = R                              |
|                                    |
|o1 : PolynomialRing                 |
+------------------------------------+
|i2 : I = ideal"x2,xy,y3"            |
|                                    |
|             2        3             |
|o2 = ideal (x , x*y, y )            |
|                                    |
|o2 : Ideal of R                     |
+------------------------------------+
|i3 : elapsedTime monAnalyticSpread I|
| -- 0.07907 seconds elapsed         |
|                                    |
|o3 = 2                              |
+------------------------------------+

See also
========

  * NP -- the Newton polyhedron of a monomial ideal

Ways to use monAnalyticSpread :
===============================

  * "monAnalyticSpread(Ideal)"

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

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

monjMult -- j-multiplicity of a monomial ideal
**********************************************

Synopsis
========

  * Usage:
        monjMult I
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * an integer (Macaulay2Doc), the j-multiplicity of I.

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

Given a monomial ideal I, this function computes the j-multiplicity of I
following the method of Jeffries-Montaño.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = (ideal"xy5,x2y3,x3y2")^4                                            |
|                                                                             |
|             4 20   5 18   6 17   6 16   7 15   8 14   7 14   8 13   9 12    |
|o2 = ideal (x y  , x y  , x y  , x y  , x y  , x y  , x y  , x y  , x y  ,   |
|     ------------------------------------------------------------------------|
|      10 11   8 12   9 11   10 10   11 9   12 8                              |
|     x  y  , x y  , x y  , x  y  , x  y , x  y )                             |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : elapsedTime monjMult I                                                  |
| -- 0.100687 seconds elapsed                                                 |
|                                                                             |
|o3 = 192                                                                     |
+-----------------------------------------------------------------------------+
|i4 : elapsedTime jMult I                                                     |
| -- 0.849161 seconds elapsed                                                 |
|                                                                             |
|o4 = 192                                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * multiplicitySequence -- the multiplicity
    sequence of an ideal
  * jMult -- the j-multiplicity of an ideal
  * monReduction -- the minimal monomial reduction of a
    monomial ideal
  * NP -- the Newton polyhedron of a monomial ideal

Ways to use monjMult :
======================

  * "monjMult(Ideal)"

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

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

monReduction -- the minimal monomial reduction of a monomial ideal
******************************************************************

Synopsis
========

  * Usage:
        monReduction(I)
  * Inputs:
      * I, a monomial ideal (Macaulay2Doc),
  * Outputs:
      * a monomial ideal (Macaulay2Doc), the minimal
        monomial reduction of I

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

Given a monomial ideal I, this function computes a monomial reduction of I
(i.e. a reduction of I which is a monomial ideal), which is inclusion-wise
minimal among all monomial reductions of I.

+----------------------------------------------+
|i1 : R = QQ[x,y]                              |
|                                              |
|o1 = R                                        |
|                                              |
|o1 : PolynomialRing                           |
+----------------------------------------------+
|i2 : I = ideal"x2,xy,y3"                      |
|                                              |
|             2        3                       |
|o2 = ideal (x , x*y, y )                      |
|                                              |
|o2 : Ideal of R                               |
+----------------------------------------------+
|i3 : J = monReduction I                       |
|                                              |
|                     2        3               |
|o3 = monomialIdeal (x , x*y, y )              |
|                                              |
|o3 : MonomialIdeal of R                       |
+----------------------------------------------+
|i4 : J == I                                   |
|                                              |
|o4 = true                                     |
+----------------------------------------------+
|i5 : K = minimalReduction I                   |
|                                              |
|            9 3   9 2   1     3 3   1 2       |
|o5 = ideal (-y  + -x  + -x*y, -y  + -x  + x*y)|
|            4     2     2     4     2         |
|                                              |
|o5 : Ideal of R                               |
+----------------------------------------------+
|i6 : degree J, degree K                       |
|                                              |
|o6 = (4, 6)                                   |
|                                              |
|o6 : Sequence                                 |
+----------------------------------------------+

This function works by finding the extremal rays of NP(I), which correspond to
the minimal generators of the monomial reduction of I.

Caveat
======

As seen above, a monomial minimal reduction need not be a minimal reduction.

See also
========

  * NP -- the Newton polyhedron of a monomial ideal

Ways to use monReduction :
==========================

  * "monReduction(Ideal)"

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

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

multiplicitySequence -- the multiplicity sequence of an ideal
*************************************************************

Synopsis
========

  * Usage:
        multiplicitySequence I
        multiplicitySequence(i, I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
      * i, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * DoSaturate, => ..., default value false, the
        Hilbert sequence of a multi-graded module
      * minTerms => ..., default value -1
      * numCandidates => ..., default value 3
      * Strategy => ..., default value "grGr"
  * Outputs:
      * a hash table (Macaulay2Doc), the multiplicity sequence
        of I

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

Given a (graded) ideal I, this function computes the multiplicity sequence as
defined in [0]. Specifying Strategy => "genElts" will use the general element
method as in [4]: one can specify the "complexity" of the general elements by
using the option minTerms.

+----------------------------+
|i1 : R = QQ[x,y,z]          |
|                            |
|o1 = R                      |
|                            |
|o1 : PolynomialRing         |
+----------------------------+
|i2 : I = ideal"xy2,yz3,zx4" |
|                            |
|               2     3   4  |
|o2 = ideal (x*y , y*z , x z)|
|                            |
|o2 : Ideal of R             |
+----------------------------+
|i3 : multiplicitySequence I |
|                            |
|o3 = HashTable{2 => 9 }     |
|               3 => 25      |
|                            |
|o3 : HashTable              |
+----------------------------+

The j-multiplicity of I is the l-th number, where l is the analytic spread of
I.

+------------------------------+
|i4 : analyticSpread I, jMult I|
|                              |
|o4 = (3, 25)                  |
|                              |
|o4 : Sequence                 |
+------------------------------+

Note that this function does not require the ambient ring to be a polynomial
ring:

+-----------------------------------+
|i5 : S = QQ[a..d]                  |
|                                   |
|o5 = S                             |
|                                   |
|o5 : PolynomialRing                |
+-----------------------------------+
|i6 : J = ideal (a*d - b*c, c^2-b*d)|
|                                   |
|                          2        |
|o6 = ideal (- b*c + a*d, c  - b*d) |
|                                   |
|o6 : Ideal of S                    |
+-----------------------------------+
|i7 : R = S/J                       |
|                                   |
|o7 = R                             |
|                                   |
|o7 : QuotientRing                  |
+-----------------------------------+
|i8 : I = ideal(R_0^2,R_0*R_1,R_1^3)|
|                                   |
|             2        3            |
|o8 = ideal (a , a*b, b )           |
|                                   |
|o8 : Ideal of R                    |
+-----------------------------------+
|i9 : multiplicitySequence I        |
|                                   |
|o9 = HashTable{1 => 5}             |
|               2 => 7              |
|                                   |
|o9 : HashTable                     |
+-----------------------------------+

One can specify a particular element in the multiplicity sequence:

+------------------------------+
|i10 : multiplicitySequence_1 I|
|                              |
|o10 = 5                       |
+------------------------------+

Caveat
======

There are two conventions in use about the order of the sequence. The current
function follows that of [4] and in this setting the j-multiplicity of I
appears at the l-th spot, where l is the analytic spread of I. If the ideal I
is not graded, this function may produce incorrect results.

See also
========

  * jMult -- the j-multiplicity of an ideal
  * monjMult -- j-multiplicity of a monomial ideal

Ways to use multiplicitySequence :
==================================

  * "multiplicitySequence(Ideal)"
  * "multiplicitySequence(ZZ,Ideal)"

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

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

NP -- the Newton polyhedron of a monomial ideal
***********************************************

Synopsis
========

  * Usage:
        NP(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * a convex polyhedron (OldPolyhedra), the Newton
        polyhedron of the monomial ideal I

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

Given a monomial ideal I in $k[x_1,\dots,x_d]$, the convex hull in
$\mathbb{R}^d$ of the set of exponents of all monomials in I is called the
Newton polyhedron of I.

+----------------------------------------+
|i1 : R = QQ[x,y,z]                      |
|                                        |
|o1 = R                                  |
|                                        |
|o1 : PolynomialRing                     |
+----------------------------------------+
|i2 : I = ideal"x2,y3,yz"                |
|                                        |
|             2   3                      |
|o2 = ideal (x , y , y*z)                |
|                                        |
|o2 : Ideal of R                         |
+----------------------------------------+
|i3 : P = NP I                           |
|                                        |
|o3 = {ambient dimension => 3           }|
|      dimension of lineality space => 0 |
|      dimension of polyhedron => 3      |
|      number of facets => 5             |
|      number of rays => 3               |
|      number of vertices => 3           |
|                                        |
|o3 : Polyhedron                         |
+----------------------------------------+

Note that a monomial is in the integral closure of I if and only if its
exponent vector is in NP(I).

+------------------------------+
|i4 : J = integralClosure(I,1) |
|                              |
|                  2   3     2 |
|o4 = ideal (y*z, x , y , x*y )|
|                              |
|o4 : Ideal of R               |
+------------------------------+
|i5 : P == NP J                |
|                              |
|o5 = true                     |
+------------------------------+

See also
========

  * monReduction -- the minimal monomial reduction of a
    monomial ideal

Ways to use NP :
================

  * "NP(Ideal)"

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

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

printHilbertSequence -- prints the Hilbert sequence as a table
**************************************************************

Synopsis
========

  * Usage:
        printHilbertSequence H
  * Inputs:
      * H, a hash table (Macaulay2Doc), the Hilbert sequence
        of a module
  * Outputs:
      * a net (Macaulay2Doc), a table representing H

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

This function gives a convenient expression of the Hilbert sequence,
particularly in terms of the multiplicity sequence. For instance, if I is an
ideal, then the multiplicity sequence of I appears as the top row of the table
for the Hilbert sequence of gr_mGr_I.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_9]                                                        |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = minors(2, genericMatrix(R, 3, 3))                                   |
|                                                                             |
|o2 = ideal (- x x  + x x , - x x  + x x , - x x  + x x , - x x  + x x , -    |
|               2 4    1 5     3 4    1 6     3 5    2 6     2 7    1 8       |
|     ------------------------------------------------------------------------|
|     x x  + x x , - x x  + x x , - x x  + x x , - x x  + x x , - x x  + x x )|
|      3 7    1 9     3 8    2 9     5 7    4 8     6 7    4 9     6 8    5 9 |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : multiplicitySequence I                                                  |
|                                                                             |
|o3 = HashTable{4 => 6 }                                                      |
|               5 => 12                                                       |
|               6 => 12                                                       |
|               7 => 6                                                        |
|               8 => 3                                                        |
|               9 => 2                                                        |
|                                                                             |
|o3 : HashTable                                                               |
+-----------------------------------------------------------------------------+
|i4 : printHilbertSequence hilbertSequence grGr I                             |
|                                                                             |
|o4 =     0 1 2 3 4   5   6   7  8  9                                         |
|       +-----------------------------                                        |
|     9 | . . . . 6   12  12  6  3  2                                         |
|     8 | . . . . -18 -30 -21 -9 -4 .                                         |
|     7 | . . . . 19  23  10  3  .  .                                         |
|     6 | . . . . -8  -5  -1  .  .  .                                         |
|     5 | . . . . 1   .   .   .  .  .                                         |
|     4 | . . . . .   .   .   .  .  .                                         |
|     3 | . . . . .   .   .   .  .  .                                         |
|     2 | . . . . .   .   .   .  .  .                                         |
|     1 | . . . . .   .   .   .  .  .                                         |
|     0 | . . . . .   .   .   .  .  .                                         |
+-----------------------------------------------------------------------------+

See also
========

  * hilbertSequence -- the Hilbert sequence of a
    multi-graded module

Ways to use printHilbertSequence :
==================================

  * "printHilbertSequence(HashTable)"

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

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