Macaulay2 » Documentation
Packages » MonomialIntegerPrograms :: monomialIdealsWithHilbertFunction
next | previous | forward | backward | up | index | toc

# monomialIdealsWithHilbertFunction -- find all monomial ideals in a polynomial ring with a particular (partial or complete) Hilbert function

- Usage:
    `monomialIdealsWithHilbertFunction(L, R)`
    `monomialIdealsWithHilbertFunction(L, R, BoundGenerators => a)`
    `monomialIdealsWithHilbertFunction(L, R, FirstBetti => b)`
    `monomialIdealsWithHilbertFunction(L, R, GradedBettis => B)`
    `monomialIdealsWithHilbertFunction(L, R, SquareFree => x)`
- Inputs:
  - L, a list, $\{h(0), h(1), \ldots, h(d)\}$, the values of a valid Hilbert function for $R$ for degrees $0\ldots d$.
  - R, a polynomial ring,
- Optional inputs:
  - BoundGenerators => an integer, default value -1, a degree bound on the monomial generators
  - FirstBetti => an integer, default value null, a specified first total Betti number
  - GradedBettis => a list, default value null, if the form $\{b_0, b_1, \ldots, b_d\}$, where $b_i$ is the first graded Betti numbers with degree $i$.
  - SquareFree => a Boolean value, default value false, whether or not to consider squarefree monomial ideals only
- Outputs:
  - a list, all ideals $I$ of $R$ that satisfy $HF(R/I, i) = h(i)$ for all $0\le i\le d$

## Description

For example, count the monomial ideals in $\mathbb{Q}[x,y,z]$, generated in degrees up to 5, whose Hilbert function begins with $\{1, 3, 6, 5, 4, 4\}$:

    i1 : R = QQ[x,y,z]; L = {1, 3, 6, 5, 4, 4};

    i3 : M = monomialIdealsWithHilbertFunction(L, R); #M

    o4 = 306

    i5 : netList take(M, 5)

         +-------------------------------------------------+
         |                2      2   2      2     2        |
    o5 = |monomialIdeal (x y, x*y , x z, x*z , y*z )       |
         +-------------------------------------------------+
         |                2      2   2      2     2        |
         |monomialIdeal (x y, x*y , y z, x*z , y*z )       |
         +-------------------------------------------------+
         |                2      2          3      2     2 |
         |monomialIdeal (x y, x*y , x*y*z, y z, x*z , y*z )|
         +-------------------------------------------------+
         |                2      2            2     2   4  |
         |monomialIdeal (x y, x*y , x*y*z, x*z , y*z , z ) |
         +-------------------------------------------------+
         |                2      2     2     2   3         |
         |monomialIdeal (x y, x*y , x*z , y*z , z )        |
         +-------------------------------------------------+

By default, the degrees of generators are bounded by the length of $L$. A lower bound can be set manually with the BoundGenerators option.

    i6 : M = monomialIdealsWithHilbertFunction(L, R, BoundGenerators => 3); #M

    o7 = 57

    i8 : netList take(M, 5)

         +----------------------------------------+
         |                3     2   3          2  |
    o8 = |monomialIdeal (x , x*y , y , x*y*z, y z)|
         +----------------------------------------+
         |                3   2    3          2   |
         |monomialIdeal (x , x y, y , x*y*z, y z) |
         +----------------------------------------+
         |                3     2   3   2         |
         |monomialIdeal (x , x*y , y , x z, x*y*z)|
         +----------------------------------------+
         |                3   2    3   2          |
         |monomialIdeal (x , x y, y , x z, x*y*z) |
         +----------------------------------------+
         |                3     2   3   2    2    |
         |monomialIdeal (x , x*y , y , x z, y z)  |
         +----------------------------------------+

There is also an option to enumerate squarefree monomial ideals only.

    i9 : S = QQ[a..f]

    o9 = S

    o9 : PolynomialRing

    i10 : I = monomialIdealsWithHilbertFunction({1, 6, 19, 45, 84}, S, SquareFree => true); #I

    o11 = 60

    i12 : first random I

    o12 = monomialIdeal (a*b, b*d, a*c*d*e, a*c*d*f, a*c*e*f, b*c*e*f, a*d*e*f,
          -----------------------------------------------------------------------
          c*d*e*f)

    o12 : MonomialIdeal of S

To specify the total number of minimal generators, use FirstBetti.

    i13 : #monomialIdealsWithHilbertFunction({1, 3, 6, 5, 4, 4}, R, FirstBetti => 5)

    o13 = 57

    i14 : #monomialIdealsWithHilbertFunction({1, 3, 6, 5, 4, 4}, R, FirstBetti => 6)

    o14 = 174

Alternatively, specify the number of minimal generators in each degree using GradedBettis. The length of the list of graded (first) Betti numbers should match the length of the partial Hilbert function.

    i15 : #monomialIdealsWithHilbertFunction({1, 3, 4, 2, 1}, R, GradedBettis => {0, 0, 2, 2, 1})

    o15 = 30

Notice that the GradedBettis option totally constrains the degrees of generators already, so do not use it with the BoundGenerators option.

You can combine BoundGenerators with FirstBetti, however, since FirstBetti does not constrain degrees.

    i16 : #monomialIdealsWithHilbertFunction({1, 3, 6, 7, 6, 5, 4, 4, 4}, R, FirstBetti => 6, BoundGenerators => 5)

    o16 = 654

    i17 : #monomialIdealsWithHilbertFunction({1, 3, 6, 7, 6, 5, 4, 4, 4}, R, FirstBetti => 6, BoundGenerators => 4)

    o17 = 60

The SquareFree option can be used with any of the other options.

    i18 : #monomialIdealsWithHilbertFunction({1, 4, 7, 10, 13}, S, SquareFree => true, FirstBetti => 5)

    o18 = 240

    i19 : #monomialIdealsWithHilbertFunction({1, 4, 7, 10, 13}, S, SquareFree => true, BoundGenerators => 3)

    o19 = 300

    i20 : #monomialIdealsWithHilbertFunction({1, 4, 7, 10, 13}, S, SquareFree => true, GradedBettis => {0, 2, 3, 1, 0})

    o20 = 60

## See also

- bettiTablesWithHilbertFunction -- list or tally all Betti tables that can be obtained from monomial ideals with a particular (partial or complete) Hilbert function
- hilbertFunct -- return the Hilbert function of a polynomial ring mod a homogeneous ideal as a list
- isHF -- is a finite list a Hilbert function of a polynomial ring mod a homogeneous ideal
- isSquareFree -- whether something is square free monomial ideal
- LexIdeals -- a package for working with lex ideals

## Ways to use monomialIdealsWithHilbertFunction:

- `monomialIdealsWithHilbertFunction(List,PolynomialRing)`

## For the programmer

The object monomialIdealsWithHilbertFunction is a method function with options.

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/MonomialIntegerPrograms.m2:875:0.