This is StronglyStableIdeals.info, produced by Macaulay2, version 1.26.06

StronglyStableIdeals -- Find strongly stable ideals with a given Hilbert polynomial
***********************************************************************************

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

Overview:

Strongly stable ideals are a key tool in commutative algebra and algebraic
geometry. These ideals have nice combinatorial properties that make them well
suited for both theoretical and computational applications. In the case of
polynomial rings with coefficients in a field of characteristic zero, the
notion of strongly stable ideals coincides with the notion of Borel-fixed
ideals. Such ideals are fixed by the action of the Borel subgroup of triangular
matrices and play a special role in theory of Gröbner bases because initial
ideals in generic coordinates are of this type by a famous result by Galligo.
In the context of parameter spaces of algebraic varieties, Galligo's theorem
says that each component and each intersection of components of a Hilbert
scheme contains at least a point corresponding to a scheme defined by a
Borel-fixed ideal. Hence, these ideals are distributed throughout the Hilbert
scheme and can be used to study its local structure. To this aim, in recent
years several authors developed algorithmic methods based on the use of
strongly stable ideals to construct flat families corresponding to special loci
of the Hilbert scheme. In particular, a new open cover of the Hilbert scheme
has been defined using strongly stable ideals and the action of the projective
linear group. In this construction, the list of all points corresponding to
Borel-fixed ideals in a given Hilbert scheme is needed. The main feature of
this package is a method to compute this set of points, i.e. the list of all
saturated strongly stable ideals in a polynomial ring with a given Hilbert
polynomial. The method has been theoretically introduced in [CLMR11] and
improved in [Lel12].

References:

[CLMR11] F. Cioffi, P. Lella, M.G. Marinari, M. Roggero: Segments and Hilbert
 Available at http://arxiv.org/abs/1003.2951.
schemes of points, Discrete Mathematics, 311(20):2238–2252, 2011.

[Lel12] P. Lella: An efficient implementation of the algorithm computing the
 Available at http://arxiv.org/abs/1205.0456.
Borel-fixed points of a Hilbert scheme, ISSAC 2012 — Proceedings of the 37th
International Symposium on Symbolic and Algebraic Computation, 242–248, ACM,
New York, 2012.

Key user functions:

Hilbert polynomials:

isHilbertPolynomial, -- Test whether a numerical
polynomial is a Hilbert polynomial.

See gotzmannDecomposition, -- Compute Gotzmann's
decomposition of a Hilbert polynomial.

See gotzmannNumber, -- Compute the Gotzmann number of a
Hilbert polynomial.

See macaulayDecomposition, -- Compute Macaulay's
decomposition of a Hilbert polynomial.

Strongly stable ideals and segment ideals:

lexIdeal, -- Compute the saturated lexicographic ideal with a
given Hilbert polynomial.

See stronglyStableIdeals, -- Compute the saturated
strongly stable ideals with a given Hilbert polynomial.

See isGenSegment, -- Test whether there exists a term ordering
such that each minimal generator of a strongly stable ideal is greater than all
monomials of the same degree outside the ideal.

See isRegSegment, -- Test whether the truncation of a strongly
stable ideal in degree equal to its regularity is a segment.

See isHilbSegment, -- Test whether the truncation of a
strongly stable ideal in degree equal to the Gotzmann number of its Hilbert
polynomial is a segment.

+-----------------------------------------+
|i1 : QQ[t];                              |
+-----------------------------------------+
|i2 : isHilbertPolynomial(3*t+4)          |
|                                         |
|o2 = true                                |
+-----------------------------------------+
|i3 : gotzmannNumber(3*t+4)               |
|                                         |
|o3 = 7                                   |
+-----------------------------------------+
|i4 : ideals = stronglyStableIdeals(3, 3);|
+-----------------------------------------+
|i5 : #ideals                             |
|                                         |
|o5 = 2                                   |
+-----------------------------------------+
|i6 : ideals#0                            |
|                                         |
|                 3                       |
|o6 = ideal (x , x )                      |
|             0   1                       |
|                                         |
|o6 : Ideal of QQ[x ..x ]                 |
|                  0   2                  |
+-----------------------------------------+

See also
========

  * isHilbertPolynomial -- Determine whether a
    numerical polynomial can be a Hilbert polynomial
  * gotzmannNumber -- Compute the Gotzmann number of a
    Hilbert polynomial
  * gotzmannDecomposition -- Compute Gotzmann's
    decomposition of Hilbert polynomial
  * stronglyStableIdeals -- Compute the saturated
    strongly stable ideals in the given ambient space with given Hilbert
    polynomial
  * lexIdeal -- Compute the saturated lexicographic ideal in
    the given ambient space with given Hilbert polynomial

Authors
=======

  * Davide Alberelli <davide.alberelli@gmail.com>
  * Paolo Lella (see http://www.paololella.it/ ) <paolo.lella@polimi.it>

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

Version 1.1 of this package was accepted for publication in volume 9 (see
https://msp.org/jsag/2018/9-1/ ) of The Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 4 November 2018, in the article
Strongly stable ideals and Hilbert polynomials (see
https://msp.org/jsag/2019/9-1/p01.xhtml ) (DOI: 10.2140/jsag.2019.9.1 (see
https://doi.org/10.2140/jsag.2019.9.1 )). That version can be obtained from the
journal (see https://msp.org/jsag/2019/9-1/jsag-v9-n1-x01-StronglyStableIdeals.
m2 ).

Version
=======

This documentation describes version 1.1 of StronglyStableIdeals, released June
2018.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{StronglyStableIdealsSource,                                            |
|  title = {{StronglyStableIdeals: studying strongly stable ideals related to |
|  author = {Davide Alberelli and Paolo Lella},                               |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{StronglyStableIdealsArticle,                                        |
|  title = {{Strongly stable ideals and Hilbert polynomials}},                |
|  author = {Davide Alberelli and Paolo Lella},                               |
|  journal = {The Journal of Software for Algebra and Geometry},              |
|  volume = {9},                                                              |
|  year = {2018},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|Hilbert polynomials. Version~1.1}},                                          |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * gotzmannDecomposition -- Compute
        Gotzmann's decomposition of Hilbert polynomial
      * gotzmannNumber -- Compute the Gotzmann number of
        a Hilbert polynomial
      * isGenSegment -- gen-segment ideals
      * isHilbertPolynomial -- Determine whether a
        numerical polynomial can be a Hilbert polynomial
      * isHilbSegment -- hilb-segment ideals
      * isRegSegment -- reg-segment ideals
      * lexIdeal -- Compute the saturated lexicographic ideal
        in the given ambient space with given Hilbert polynomial
      * macaulayDecomposition -- Compute
        Macaulay's decomposition of Hilbert polynomial
      * stronglyStableIdeals -- Compute the
        saturated strongly stable ideals in the given ambient space with given
        Hilbert polynomial
  * Methods
      * "gotzmannDecomposition(ProjectiveHilbertPolynomial)" -- see
        gotzmannDecomposition, -- Compute Gotzmann's
        decomposition of Hilbert polynomial
      * "gotzmannDecomposition(RingElement)" -- see
        gotzmannDecomposition, -- Compute Gotzmann's
        decomposition of Hilbert polynomial
      * "gotzmannNumber(ProjectiveHilbertPolynomial)" -- see
        gotzmannNumber, -- Compute the Gotzmann number of a
        Hilbert polynomial
      * "gotzmannNumber(RingElement)" -- see gotzmannNumber,
        -- Compute the Gotzmann number of a Hilbert polynomial
      * "isGenSegment(Ideal)" -- see isGenSegment, --
        gen-segment ideals
      * "isGenSegment(MonomialIdeal)" -- see isGenSegment,
        -- gen-segment ideals
      * "isHilbertPolynomial(ProjectiveHilbertPolynomial)" -- see
        isHilbertPolynomial, -- Determine whether a
        numerical polynomial can be a Hilbert polynomial
      * "isHilbertPolynomial(RingElement)" -- see isHilbertPolynomial,
        -- Determine whether a numerical polynomial can be
        a Hilbert polynomial
      * "isHilbSegment(Ideal)" -- see isHilbSegment, --
        hilb-segment ideals
      * "isHilbSegment(MonomialIdeal)" -- see isHilbSegment,
        -- hilb-segment ideals
      * "isRegSegment(Ideal)" -- see isRegSegment, --
        reg-segment ideals
      * "isRegSegment(MonomialIdeal)" -- see isRegSegment,
        -- reg-segment ideals
      * "lexIdeal(ProjectiveHilbertPolynomial,PolynomialRing)" -- see
        lexIdeal, -- Compute the saturated lexicographic ideal in the
        given ambient space with given Hilbert polynomial
      * "lexIdeal(ProjectiveHilbertPolynomial,ZZ)" -- see lexIdeal,
        -- Compute the saturated lexicographic ideal in the given
        ambient space with given Hilbert polynomial
      * "lexIdeal(RingElement,PolynomialRing)" -- see lexIdeal,
        -- Compute the saturated lexicographic ideal in the given ambient space
        with given Hilbert polynomial
      * "lexIdeal(RingElement,ZZ)" -- see lexIdeal, -- Compute
        the saturated lexicographic ideal in the given ambient space with given
        Hilbert polynomial
      * "lexIdeal(ZZ,PolynomialRing)" -- see lexIdeal, --
        Compute the saturated lexicographic ideal in the given ambient space
        with given Hilbert polynomial
      * "lexIdeal(ZZ,ZZ)" -- see lexIdeal, -- Compute the
        saturated lexicographic ideal in the given ambient space with given
        Hilbert polynomial
      * "macaulayDecomposition(ProjectiveHilbertPolynomial)" -- see
        macaulayDecomposition, -- Compute Macaulay's
        decomposition of Hilbert polynomial
      * "macaulayDecomposition(RingElement)" -- see
        macaulayDecomposition, -- Compute Macaulay's
        decomposition of Hilbert polynomial
      * projectiveHilbertPolynomial(RingElement)
      * "stronglyStableIdeals(ProjectiveHilbertPolynomial,PolynomialRing)" --
        see stronglyStableIdeals, -- Compute the
        saturated strongly stable ideals in the given ambient space with given
        Hilbert polynomial
      * "stronglyStableIdeals(ProjectiveHilbertPolynomial,ZZ)" -- see
        stronglyStableIdeals, -- Compute the saturated
        strongly stable ideals in the given ambient space with given Hilbert
        polynomial
      * "stronglyStableIdeals(RingElement,PolynomialRing)" -- see
        stronglyStableIdeals, -- Compute the saturated
        strongly stable ideals in the given ambient space with given Hilbert
        polynomial
      * "stronglyStableIdeals(RingElement,ZZ)" -- see
        stronglyStableIdeals, -- Compute the saturated
        strongly stable ideals in the given ambient space with given Hilbert
        polynomial
      * "stronglyStableIdeals(ZZ,PolynomialRing)" -- see
        stronglyStableIdeals, -- Compute the saturated
        strongly stable ideals in the given ambient space with given Hilbert
        polynomial
      * "stronglyStableIdeals(ZZ,ZZ)" -- see stronglyStableIdeals,
        -- Compute the saturated strongly stable ideals
        in the given ambient space with given Hilbert polynomial
  * Symbols
      * MaxRegularity -- Option to set the maximum
        regularity
      * OrderVariables -- Option to set the order of
        indexed variables

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

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

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

The source of this document is in StronglyStableIdeals.m2:748:0.

gotzmannDecomposition -- Compute Gotzmann's decomposition of Hilbert polynomial
*******************************************************************************

  * Usage:
        gotzmannDecomposition hp
  * Inputs:
      * hp, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * hp, a ring element (Macaulay2Doc), a Hilbert
        polynomial.
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the list of projective Hilbert polynomials of linear spaces summing up
to the input polynomial:

+-------------------------------------------------+
|i1 : QQ[t];                                      |
+-------------------------------------------------+
|i2 : hp = projectiveHilbertPolynomial(3*t+4)     |
|                                                 |
|o2 = P  + 3*P                                    |
|      0      1                                   |
|                                                 |
|o2 : ProjectiveHilbertPolynomial                 |
+-------------------------------------------------+
|i3 : gD = gotzmannDecomposition hp               |
|                                                 |
|o3 = {P , - P  + P , - 2*P  + P , P , P , P , P }|
|       1     0    1       0    1   0   0   0   0 |
|                                                 |
|o3 : List                                        |
+-------------------------------------------------+
|i4 : sum gD                                      |
|                                                 |
|o4 = P  + 3*P                                    |
|      0      1                                   |
|                                                 |
|o4 : ProjectiveHilbertPolynomial                 |
+-------------------------------------------------+

The decomposition suggests the most degenerate geometric object with the given
Hilbert polynomial.

+-------------------------------------------------------------+
|i5 : R = QQ[x,y,z,w];                                        |
+-------------------------------------------------------------+
|i6 : completeIntersection22 = ideal(random(2,R),random(2,R));|
|                                                             |
|o6 : Ideal of R                                              |
+-------------------------------------------------------------+
|i7 : hp = hilbertPolynomial completeIntersection22           |
|                                                             |
|o7 = - 4*P  + 4*P                                            |
|          0      1                                           |
|                                                             |
|o7 : ProjectiveHilbertPolynomial                             |
+-------------------------------------------------------------+
|i8 : gD = gotzmannDecomposition hp                           |
|                                                             |
|o8 = {P , - P  + P , - 2*P  + P , - 3*P  + P , P , P }       |
|       1     0    1       0    1       0    1   0   0        |
|                                                             |
|o8 : List                                                    |
+-------------------------------------------------------------+

The degree of hp is 1, so it is possible to obtain hp as Hilbert polynomial of
a scheme in the plane. Gotzmann's decomposition has 4 terms of degree 1 and 2
term of degree 0. This suggests that the generic union of 4 lines and 2 points
in a plane should have Hilbert polynomial hp:

+--------------------------------------------------------------------------+
|i9 : H = random(1,R);                                                     |
+--------------------------------------------------------------------------+
|i10 : fourLines = for i from 1 to 4 list ideal(H,random(1,R));            |
+--------------------------------------------------------------------------+
|i11 : twoPoints = for i from 1 to 2 list ideal(H,random(1,R),random(1,R));|
+--------------------------------------------------------------------------+
|i12 : unionLinesPoints = intersect(fourLines|twoPoints);                  |
|                                                                          |
|o12 : Ideal of R                                                          |
+--------------------------------------------------------------------------+
|i13 : hilbertPolynomial unionLinesPoints == hp                            |
|                                                                          |
|o13 = true                                                                |
+--------------------------------------------------------------------------+

Ways to use gotzmannDecomposition:
==================================

  * "gotzmannDecomposition(ProjectiveHilbertPolynomial)"
  * "gotzmannDecomposition(RingElement)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:824:0.

gotzmannNumber -- Compute the Gotzmann number of a Hilbert polynomial
*********************************************************************

  * Usage:
        gotzmannNumber hp
  * Inputs:
      * hp, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * hp, a ring element (Macaulay2Doc), a Hilbert
        polynomial.
  * Outputs:
      * an integer (Macaulay2Doc),

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

Returns the Gotzmann number of the input polynomial, i.e. the length of its
Gotzmann decomposition (see gotzmannDecomposition).

+-------------------------------------------------+
|i1 : QQ[t];                                      |
+-------------------------------------------------+
|i2 : gotzmannNumber(3*t+4)                       |
|                                                 |
|o2 = 7                                           |
+-------------------------------------------------+
|i3 : gotzmannDecomposition(3*t+4)                |
|                                                 |
|o3 = {P , - P  + P , - 2*P  + P , P , P , P , P }|
|       1     0    1       0    1   0   0   0   0 |
|                                                 |
|o3 : List                                        |
+-------------------------------------------------+

Ways to use gotzmannNumber:
===========================

  * "gotzmannNumber(ProjectiveHilbertPolynomial)"
  * "gotzmannNumber(RingElement)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:877:0.

isGenSegment -- gen-segment ideals
**********************************

  * Usage:
        isGenSegment J
  * Inputs:
      * J, a monomial ideal (Macaulay2Doc), or
      * J, an ideal (Macaulay2Doc), a strongly stable ideal.
  * Outputs:
      * a sequence (Macaulay2Doc),

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

The first element of the sequence is a boolean value. It tells if the ideal is
a segment, i.e. if there exists a term ordering such that every generator of
the ideal is strictly greater than every monomial outside the ideal of the same
degree. If true, the second element of the sequence contains the list of
weights giving the corresponding ordering on the monomials.

+---------------------------------------+
|i1 : QQ[x,y,z];                        |
+---------------------------------------+
|i2 : isGenSegment(ideal(x^2,x*y,y^4))  |
|                                       |
|o2 = (true, {6, 3, 1})                 |
|                                       |
|o2 : Sequence                          |
+---------------------------------------+
|i3 : isGenSegment(ideal(x^2,x*y^3,y^4))|
|                                       |
|o3 = (true, {4, 3, 1})                 |
|                                       |
|o3 : Sequence                          |
+---------------------------------------+

Ways to use isGenSegment:
=========================

  * "isGenSegment(Ideal)"
  * "isGenSegment(MonomialIdeal)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:1126:0.

isHilbertPolynomial -- Determine whether a numerical polynomial can be a Hilbert polynomial
*******************************************************************************************

  * Usage:
        isHilbertPolynomial p
  * Inputs:
      * p, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * p, a ring element (Macaulay2Doc), a numerical
        univariate polynomial.
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Returns true if the input polynomial is an admissible Hilbert polynomial, false
otherwise.

+-------------------------------------------------------------+
|i1 : QQ[t];                                                  |
+-------------------------------------------------------------+
|i2 : isHilbertPolynomial(3*t+4)                              |
|                                                             |
|o2 = true                                                    |
+-------------------------------------------------------------+
|i3 : isHilbertPolynomial((2/3)*t-1)                          |
|                                                             |
|o3 = false                                                   |
+-------------------------------------------------------------+
|i4 : isHilbertPolynomial(2*projectiveHilbertPolynomial(2))   |
|                                                             |
|o4 = true                                                    |
+-------------------------------------------------------------+
|i5 : isHilbertPolynomial(2*projectiveHilbertPolynomial(2,-1))|
|                                                             |
|o5 = false                                                   |
+-------------------------------------------------------------+

Ways to use isHilbertPolynomial:
================================

  * "isHilbertPolynomial(ProjectiveHilbertPolynomial)"
  * "isHilbertPolynomial(RingElement)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:776:0.

isHilbSegment -- hilb-segment ideals
************************************

  * Usage:
        isHilbSegment J
  * Inputs:
      * J, a monomial ideal (Macaulay2Doc), or
      * J, an ideal (Macaulay2Doc), a strongly stable ideal.
  * Outputs:
      * a sequence (Macaulay2Doc),

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

Calls the method isGenSegment, on the ideal
truncate(gotzmannNumber(hilbertPolynomial J), J).

+-------------------------------------------------------------------+
|i1 : QQ[x,y,z];                                                    |
+-------------------------------------------------------------------+
|i2 : J = ideal(x^2,x*y,y^4);                                       |
|                                                                   |
|o2 : Ideal of QQ[x..z]                                             |
+-------------------------------------------------------------------+
|i3 : isHilbSegment J                                               |
|                                                                   |
|o3 = (true, {7, 3, 1})                                             |
|                                                                   |
|o3 : Sequence                                                      |
+-------------------------------------------------------------------+
|i4 : isGenSegment(truncate(gotzmannNumber(hilbertPolynomial J), J))|
|                                                                   |
|o4 = (true, {7, 3, 1})                                             |
|                                                                   |
|o4 : Sequence                                                      |
+-------------------------------------------------------------------+

Ways to use isHilbSegment:
==========================

  * "isHilbSegment(Ideal)"
  * "isHilbSegment(MonomialIdeal)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:1181:0.

isRegSegment -- reg-segment ideals
**********************************

  * Usage:
        isRegSegment J
  * Inputs:
      * J, a monomial ideal (Macaulay2Doc), or
      * J, an ideal (Macaulay2Doc), a strongly stable ideal.
  * Outputs:
      * a sequence (Macaulay2Doc),

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

Calls the method isGenSegment, on the ideal
truncate(regularity J, J).

+-------------------------------------------+
|i1 : QQ[x,y,z];                            |
+-------------------------------------------+
|i2 : J = ideal(x^2,x*y^3,y^4)              |
|                                           |
|             2     3   4                   |
|o2 = ideal (x , x*y , y )                  |
|                                           |
|o2 : Ideal of QQ[x..z]                     |
+-------------------------------------------+
|i3 : isRegSegment J                        |
|                                           |
|o3 = (false, )                             |
|                                           |
|o3 : Sequence                              |
+-------------------------------------------+
|i4 : isGenSegment(truncate(regularity J,J))|
|                                           |
|o4 = (false, )                             |
|                                           |
|o4 : Sequence                              |
+-------------------------------------------+
|i5 : isGenSegment J                        |
|                                           |
|o5 = (true, {4, 3, 1})                     |
|                                           |
|o5 : Sequence                              |
+-------------------------------------------+

Ways to use isRegSegment:
=========================

  * "isRegSegment(Ideal)"
  * "isRegSegment(MonomialIdeal)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:1154:0.

lexIdeal -- Compute the saturated lexicographic ideal in the given ambient space with given Hilbert polynomial
**************************************************************************************************************

  * Usage:
        lexIdeal (hp ,S)
        lexIdeal (hp, n)
        lexIdeal (d, S)
        lexIdeal (d, n)
  * Inputs:
      * hp, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * hp, a ring element (Macaulay2Doc), a Hilbert
        polynomial;
      * d, an integer (Macaulay2Doc), a positive integer
        corresponding to a constant Hilbert polynomial;
      * S, a polynomial ring (Macaulay2Doc), with numgens
        S > 1;
      * n, an integer (Macaulay2Doc), number of variables of the
        polynomial ring.
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ..., default
        value QQ, Option to set the ring of coefficients
      * OrderVariables,
        => ..., default value Down, Option to set the order of indexed
        variables
  * Outputs:
      * an ideal (Macaulay2Doc),

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

Returns the saturated lexicographic ideal defining a subscheme of
\mathbb{P}^{n} or Proj S with Hilbert polynomial hp or d.

+--------------------------------+
|i1 : QQ[t];                     |
+--------------------------------+
|i2 : S = QQ[x,y,z,w];           |
+--------------------------------+
|i3 : lexIdeal(4*t, S)           |
|                                |
|                5   4 2         |
|o3 = ideal (x, y , y z )        |
|                                |
|o3 : Ideal of S                 |
+--------------------------------+
|i4 : lexIdeal(4*t, 5)           |
|                                |
|                     5   4 2    |
|o4 = ideal (x , x , x , x x )   |
|             1   0   2   2 3    |
|                                |
|o4 : Ideal of QQ[x ..x ]        |
|                  0   4         |
+--------------------------------+
|i5 : hp = hilbertPolynomial oo  |
|                                |
|o5 = - 4*P  + 4*P               |
|          0      1              |
|                                |
|o5 : ProjectiveHilbertPolynomial|
+--------------------------------+
|i6 : lexIdeal(hp, S)            |
|                                |
|                5   4 2         |
|o6 = ideal (x, y , y z )        |
|                                |
|o6 : Ideal of S                 |
+--------------------------------+
|i7 : lexIdeal(hp, 3)            |
|                                |
|             5   4 2            |
|o7 = ideal (x , x x )           |
|             0   0 1            |
|                                |
|o7 : Ideal of QQ[x ..x ]        |
|                  0   2         |
+--------------------------------+
|i8 : lexIdeal(5, S)             |
|                                |
|                   5            |
|o8 = ideal (y, x, z )           |
|                                |
|o8 : Ideal of S                 |
+--------------------------------+
|i9 : lexIdeal(5, 3)             |
|                                |
|                 5              |
|o9 = ideal (x , x )             |
|             0   1              |
|                                |
|o9 : Ideal of QQ[x ..x ]        |
|                  0   2         |
+--------------------------------+

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

  * "lexIdeal(ProjectiveHilbertPolynomial,PolynomialRing)"
  * "lexIdeal(ProjectiveHilbertPolynomial,ZZ)"
  * "lexIdeal(RingElement,PolynomialRing)"
  * "lexIdeal(RingElement,ZZ)"
  * "lexIdeal(ZZ,PolynomialRing)"
  * "lexIdeal(ZZ,ZZ)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:963:0.

lexIdeal(...,CoefficientRing=>...) -- Option to set the ring of coefficients
****************************************************************************

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

This option can be used to specify the ring of coefficients of the polynomial
ring containing the ideals, when calling lexIdeal, giving as
input only the number of variables of the polynomial ring.

The default is QQ (Macaulay2Doc).

+---------------------------------------------+
|i1 : lexIdeal(10, 3, CoefficientRing=>ZZ/101)|
|                                             |
|                 10                          |
|o1 = ideal (x , x  )                         |
|             0   1                           |
|                                             |
|               ZZ                            |
|o1 : Ideal of ---[x ..x ]                    |
|              101  0   2                     |
+---------------------------------------------+

Functions with optional argument named CoefficientRing:
=======================================================

  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * lexIdeal(...,CoefficientRing=>...)
    -- Option to set the
    ring of coefficients
  * random(...,CoefficientRing=>...) (missing documentation)
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * stronglyStableIdeals(...,CoefficientRing=>...)
    -- Option
    to set the ring of coefficients

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

  * Default value: QQ (Macaulay2Doc),
  * Function: lexIdeal, -- Compute the saturated lexicographic
    ideal in the given ambient space with given Hilbert polynomial
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in StronglyStableIdeals.m2:979:0.

lexIdeal(...,OrderVariables=>...) -- Option to set the order of indexed variables
*********************************************************************************

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

This option can be used to specify the order of the indexed variables of the
polynomial ring containing the ideals, when calling lexIdeal,
giving as input only the number of variables of the polynomial ring. If
OrderVariables, is set to Up (Macaulay2Doc),
then x_i < x_j iff i < j, otherwise if
OrderVariables, is set to Down (Macaulay2Doc),
then x_i < x_j iff i > j.

The default is Down (Macaulay2Doc).

+-----------------------------------------+
|i1 : lexIdeal(3, 3, OrderVariables=>Down)|
|                                         |
|                 3                       |
|o1 = ideal (x , x )                      |
|             0   1                       |
|                                         |
|o1 : Ideal of QQ[x ..x ]                 |
|                  0   2                  |
+-----------------------------------------+
|i2 : lexIdeal(3, 3, OrderVariables=>Up)  |
|                                         |
|                 3                       |
|o2 = ideal (x , x )                      |
|             2   1                       |
|                                         |
|o2 : Ideal of QQ[x , x , x ]             |
|                  2   1   0              |
+-----------------------------------------+

Functions with optional argument named OrderVariables:
======================================================

  * lexIdeal(...,OrderVariables=>...)
    -- Option to set the
    order of indexed variables
  * stronglyStableIdeals(...,OrderVariables=>...)
    -- Option
    to set the order of indexed variables

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

  * Default value: Down (Macaulay2Doc),
  * Function: lexIdeal, -- Compute the saturated lexicographic
    ideal in the given ambient space with given Hilbert polynomial
  * Option key: OrderVariables, -- Option to set the
    order of indexed variables
-------------------------------------------------------------------------------

The source of this document is in StronglyStableIdeals.m2:998:0.

macaulayDecomposition -- Compute Macaulay's decomposition of Hilbert polynomial
*******************************************************************************

  * Usage:
        macaulayDecomposition hp
  * Inputs:
      * hp, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * hp, a ring element (Macaulay2Doc), a Hilbert
        polynomial.
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the list of projective Hilbert polynomials of linear spaces summing up
to the input polynomial:

+----------------------------------------------------------+
|i1 : QQ[t];                                               |
+----------------------------------------------------------+
|i2 : hp = projectiveHilbertPolynomial(3*t+4)              |
|                                                          |
|o2 = P  + 3*P                                             |
|      0      1                                            |
|                                                          |
|o2 : ProjectiveHilbertPolynomial                          |
+----------------------------------------------------------+
|i3 : mD = macaulayDecomposition hp                        |
|                                                          |
|o3 = {- P  + P , 8*P  - P , - P  + P , - 6*P  + 4*P  - P }|
|         0    1     0    1     1    2       0      1    2 |
|                                                          |
|o3 : List                                                 |
+----------------------------------------------------------+
|i4 : sum mD                                               |
|                                                          |
|o4 = P  + 3*P                                             |
|      0      1                                            |
|                                                          |
|o4 : ProjectiveHilbertPolynomial                          |
+----------------------------------------------------------+

Ways to use macaulayDecomposition:
==================================

  * "macaulayDecomposition(ProjectiveHilbertPolynomial)"
  * "macaulayDecomposition(RingElement)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:851:0.

MaxRegularity -- Option to set the maximum regularity
*****************************************************

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

This option can be used to give an upper bound to the regularity of the
strongly stable ideals.

The default is null (i.e. no bound).

+-------------------------------------------------------+
|i1 : QQ[t];                                            |
+-------------------------------------------------------+
|i2 : stronglyStableIdeals(4*t, 4, MaxRegularity=>4)    |
|                                                       |
|                    2     2   4                 2   3  |
|o2 = {ideal (x x , x , x x , x ), ideal (x x , x , x )}|
|              0 1   0   0 2   1           0 1   0   1  |
|                                                       |
|o2 : List                                              |
+-------------------------------------------------------+

Functions with optional argument named MaxRegularity:
=====================================================

  * "stronglyStableIdeals(...,MaxRegularity=>...)"

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

The object MaxRegularity, is a symbol (Macaulay2Doc).

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

The source of this document is in StronglyStableIdeals.m2:1061:0.

OrderVariables -- Option to set the order of indexed variables
**************************************************************

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

This option can be used to specify the order of the indexed variables of the
polynomial ring containing the ideals, when calling lexIdeal,
or stronglyStableIdeals, giving as input only the
number of variables of the polynomial ring. If OrderVariables,
is set to Up (Macaulay2Doc), then x_i < x_j
iff i < j, otherwise if OrderVariables, is set to
Down (Macaulay2Doc), then x_i < x_j iff i > j.

The default is Down (Macaulay2Doc).

+---------------------------------------------------+
|i1 : lexIdeal(3, 3, OrderVariables=>Down)          |
|                                                   |
|                 3                                 |
|o1 = ideal (x , x )                                |
|             0   1                                 |
|                                                   |
|o1 : Ideal of QQ[x ..x ]                           |
|                  0   2                            |
+---------------------------------------------------+
|i2 : stronglyStableIdeals(3, 3, OrderVariables=>Up)|
|                                                   |
|                  3           2         2          |
|o2 = {ideal (x , x ), ideal (x , x x , x )}        |
|              2   1           1   2 1   2          |
|                                                   |
|o2 : List                                          |
+---------------------------------------------------+

Functions with optional argument named OrderVariables:
======================================================

  * lexIdeal(...,OrderVariables=>...)
    -- Option to set the
    order of indexed variables
  * stronglyStableIdeals(...,OrderVariables=>...)
    -- Option
    to set the order of indexed variables

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

The object OrderVariables, is a symbol (Macaulay2Doc).

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

The source of this document is in StronglyStableIdeals.m2:917:0.

projectiveHilbertPolynomial(RingElement)
****************************************

  * Function: projectiveHilbertPolynomial (Macaulay2Doc),
  * Usage:
        projectiveHilbertPolynomial p
  * Inputs:
      * p, a ring element (Macaulay2Doc), a Hilbert
        polynomial.
  * Outputs:
      * a projective Hilbert polynomial (Macaulay2Doc),

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

Convert a RingElement (Macaulay2Doc), representing a Hilbert
polynomial to a ProjectiveHilbertPolynomial (Macaulay2Doc).

+----------------------------------------+
|i1 : QQ[t];                             |
+----------------------------------------+
|i2 : projectiveHilbertPolynomial (3*t+4)|
|                                        |
|o2 = P  + 3*P                           |
|      0      1                          |
|                                        |
|o2 : ProjectiveHilbertPolynomial        |
+----------------------------------------+

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

  * projectiveHilbertPolynomial(RingElement)
-------------------------------------------------------------------------------

The source of this document is in StronglyStableIdeals.m2:898:0.

stronglyStableIdeals -- Compute the saturated strongly stable ideals in the given ambient space with given Hilbert polynomial
*****************************************************************************************************************************

  * Usage:
        stronglyStableIdeals (hp ,S)
        stronglyStableIdeals (hp, n)
        stronglyStableIdeals (d, S)
        stronglyStableIdeals (d, n)
  * Inputs:
      * hp, a projective Hilbert polynomial (Macaulay2Doc),
        or
      * hp, a ring element (Macaulay2Doc), a Hilbert
        polynomial;
      * d, an integer (Macaulay2Doc), a positive integer
        corresponding to a constant Hilbert polynomial;
      * S, a polynomial ring (Macaulay2Doc), with numgens
        S > 1;
      * n, an integer (Macaulay2Doc), number of variables of the
        polynomial ring.
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        =>
        ..., default value QQ, Option to set the ring of coefficients
      * MaxRegularity, => ..., default value null, Option
        to set the maximum regularity
      * OrderVariables,
        => ..., default value Down, Option to set the order of
        indexed variables
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the list of all the saturated strongly stable ideals defining
subschemes of \mathbb{P}^{n} or Proj S with Hilbert polynomial hp or d.

+-----------------------------------------------------------------------------+
|i1 : QQ[t];                                                                  |
+-----------------------------------------------------------------------------+
|i2 : S = QQ[x,y,z,w];                                                        |
+-----------------------------------------------------------------------------+
|i3 : stronglyStableIdeals(4*t, S)                                            |
|                                                                             |
|                 5   4 2                     2   4    5                2     |
|o3 = {ideal (x, y , y z ), ideal (x*z, x*y, x , y z, y ), ideal (x*y, x ,    |
|     ------------------------------------------------------------------------|
|        2   4                2   3                                           |
|     x*z , y ), ideal (x*y, x , y )}                                         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : stronglyStableIdeals(4*t, 4)                                            |
|                                                                             |
|                  5   4 2                       2   4     5                  |
|o4 = {ideal (x , x , x x ), ideal (x x , x x , x , x x , x ), ideal (x x ,   |
|              0   1   1 2           0 2   0 1   0   1 2   1           0 1    |
|     ------------------------------------------------------------------------|
|      2     2   4                 2   3                                      |
|     x , x x , x ), ideal (x x , x , x )}                                    |
|      0   0 2   1           0 1   0   1                                      |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : hp = hilbertPolynomial(oo#0)                                            |
|                                                                             |
|o5 = - 4*P  + 4*P                                                            |
|          0      1                                                           |
|                                                                             |
|o5 : ProjectiveHilbertPolynomial                                             |
+-----------------------------------------------------------------------------+
|i6 : stronglyStableIdeals(hp, S)                                             |
|                                                                             |
|                 5   4 2                     2   4    5                2     |
|o6 = {ideal (x, y , y z ), ideal (x*z, x*y, x , y z, y ), ideal (x*y, x ,    |
|     ------------------------------------------------------------------------|
|        2   4                2   3                                           |
|     x*z , y ), ideal (x*y, x , y )}                                         |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : stronglyStableIdeals(hp, 4)                                             |
|                                                                             |
|                  5   4 2                       2   4     5                  |
|o7 = {ideal (x , x , x x ), ideal (x x , x x , x , x x , x ), ideal (x x ,   |
|              0   1   1 2           0 2   0 1   0   1 2   1           0 1    |
|     ------------------------------------------------------------------------|
|      2     2   4                 2   3                                      |
|     x , x x , x ), ideal (x x , x , x )}                                    |
|      0   0 2   1           0 1   0   1                                      |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : stronglyStableIdeals(5, S)                                              |
|                                                                             |
|                    5                   2   4              2   3     2       |
|o8 = {ideal (y, x, z ), ideal (x, y*z, y , z ), ideal (x, y , z , y*z ),     |
|     ------------------------------------------------------------------------|
|                       2        2   3                                        |
|     ideal (y*z, x*z, y , x*y, x , z )}                                      |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : stronglyStableIdeals(5, 4)                                              |
|                                                                             |
|                      5                     2   4               2   3     2  |
|o9 = {ideal (x , x , x ), ideal (x , x x , x , x ), ideal (x , x , x , x x ),|
|              1   0   2           0   1 2   1   2           0   1   2   1 2  |
|     ------------------------------------------------------------------------|
|                         2         2   3                                     |
|     ideal (x x , x x , x , x x , x , x )}                                   |
|             1 2   0 2   1   0 1   0   2                                     |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use stronglyStableIdeals:
=================================

  * "stronglyStableIdeals(ProjectiveHilbertPolynomial,PolynomialRing)"
  * "stronglyStableIdeals(ProjectiveHilbertPolynomial,ZZ)"
  * "stronglyStableIdeals(RingElement,PolynomialRing)"
  * "stronglyStableIdeals(RingElement,ZZ)"
  * "stronglyStableIdeals(ZZ,PolynomialRing)"
  * "stronglyStableIdeals(ZZ,ZZ)"

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

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

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

The source of this document is in StronglyStableIdeals.m2:1044:0.

stronglyStableIdeals(...,CoefficientRing=>...) -- Option to set the ring of coefficients
****************************************************************************************

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

This option can be used to specify the ring of coefficients of the polynomial
ring containing the ideals, when calling stronglyStableIdeals,
giving as input only the number of variables of the
polynomial ring.

The default is QQ (Macaulay2Doc).

+--------------------------------------------------------+
|i1 : QQ[t];                                             |
+--------------------------------------------------------+
|i2 : stronglyStableIdeals(3, 3, CoefficientRing=>ZZ/101)|
|                                                        |
|                  3           2         2               |
|o2 = {ideal (x , x ), ideal (x , x x , x )}             |
|              0   1           1   0 1   0               |
|                                                        |
|o2 : List                                               |
+--------------------------------------------------------+
|i3 : oo#0                                               |
|                                                        |
|                 3                                      |
|o3 = ideal (x , x )                                     |
|             0   1                                      |
|                                                        |
|               ZZ                                       |
|o3 : Ideal of ---[x ..x ]                               |
|              101  0   2                                |
+--------------------------------------------------------+

Functions with optional argument named CoefficientRing:
=======================================================

  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * lexIdeal(...,CoefficientRing=>...)
    -- Option to set the
    ring of coefficients
  * random(...,CoefficientRing=>...) (missing documentation)
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * stronglyStableIdeals(...,CoefficientRing=>...)
    -- Option
    to set the ring of coefficients

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

  * Default value: QQ (Macaulay2Doc),
  * Function: stronglyStableIdeals, -- Compute the
    saturated strongly stable ideals in the given ambient space with given
    Hilbert polynomial
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in StronglyStableIdeals.m2:1079:0.

stronglyStableIdeals(...,OrderVariables=>...) -- Option to set the order of indexed variables
*********************************************************************************************

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

This option can be used to specify the order of the indexed variables of the
polynomial ring containing the ideals, when calling stronglyStableIdeals,
giving as input only the number of variables of the
polynomial ring. If OrderVariables, is set to Up (Macaulay2Doc),
then x_i < x_j iff i < j, otherwise if
OrderVariables, is set to Down (Macaulay2Doc),
then x_i < x_j iff i > j.

The default is Down (Macaulay2Doc).

+-----------------------------------------------------+
|i1 : stronglyStableIdeals(3, 3, OrderVariables=>Down)|
|                                                     |
|                  3           2         2            |
|o1 = {ideal (x , x ), ideal (x , x x , x )}          |
|              0   1           1   0 1   0            |
|                                                     |
|o1 : List                                            |
+-----------------------------------------------------+
|i2 : stronglyStableIdeals(3, 3, OrderVariables=>Up)  |
|                                                     |
|                  3           2         2            |
|o2 = {ideal (x , x ), ideal (x , x x , x )}          |
|              2   1           1   2 1   2            |
|                                                     |
|o2 : List                                            |
+-----------------------------------------------------+

Functions with optional argument named OrderVariables:
======================================================

  * lexIdeal(...,OrderVariables=>...)
    -- Option to set the
    order of indexed variables
  * stronglyStableIdeals(...,OrderVariables=>...)
    -- Option
    to set the order of indexed variables

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

  * Default value: Down (Macaulay2Doc),
  * Function: stronglyStableIdeals, -- Compute the
    saturated strongly stable ideals in the given ambient space with given
    Hilbert polynomial
  * Option key: OrderVariables, -- Option to set the
    order of indexed variables
-------------------------------------------------------------------------------

The source of this document is in StronglyStableIdeals.m2:1098:0.