This is TSpreadIdeals.info, produced by Macaulay2, version 1.24.11

TSpreadIdeals -- A package for working with t-spread ideals of polynomial rings
*******************************************************************************

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

TSpreadIdeals is a package for creating and manipulating t-spread ideals of
polynomial rings. Let $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ a monomial of
$S=K[x_1,\ldots,x_n]$, with $1\le i_1\le i_2\le\dots\le i_d\le n$. The monomial
u is called $t$-spread if $i_{j+1}-i_j\ge t$ for all $j\in [d-1].$
A list of monomials is t-spread if all the monomials of the list are t-spread.
A monomial ideal is called t-spread if it is generated by t-spread monomials.
Some references can be found in the papers Computational methods for t-spread
monomial ideals (see https://arxiv.org/abs/2110.11801 ) and A numerical
characterization of the extremal Betti numbers of t-spread strongly stable
ideals (see https://arxiv.org/abs/2105.11944 ).

Author
======

  * Luca Amata (see http://mat521.unime.it/amata ) <lamata@unime.it>

Version
=======

This documentation describes version 1.0 of TSpreadIdeals.

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

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

Exports
=======

  * Functions and commands
      * countTLexMon -- give the cardinality of the
        smallest initial t-lex segment containing a given monomial
      * countTStronglyStableMon -- give the
        cardinality of the t-strongly stable set generated by a given monomial
      * fTVector -- compute the ft-vector of a given t-spread
        ideal of a polynomial ring
      * initialDegree -- return the initial degree of a
        given graded ideal
      * initialIdeal -- return the initial ideal of a
        given ideal
      * isFTVector -- whether a given list of nonnegative
        integers is the ft-vector of a t-strongly stable ideal of a given
        polynomial ring
      * isTLexIdeal -- whether a given t-spread ideal is
        t-spread lex
      * isTLexSeg -- whether a set of t-spread monomials is a
        t-lex segment
      * isTSpread -- whether a monomial, a list of monomials
        or a monomial ideal is t-spread
      * isTStronglyStableIdeal -- whether a
        given t-spread ideal is t-strongly stable
      * isTStronglyStableSeg -- whether the given
        list of t-spread monomials is a t-strongly stable segment
      * minimalBettiNumbers -- return the minimal
        Betti numbers of the quotient ring corresponding to a given graded
        ideal
      * minimalBettiNumbersIdeal -- return the
        minimal Betti numbers of a given graded ideal
      * solveBinomialExpansion -- compute the
        sum of a binomial expansion
      * tExtremalBettiCorners -- give the corners
        of the extremal Betti numbers of a given t-strongly stable ideal
      * tExtremalBettiMonomials -- give the
        list of the t-spread basic monomials related to the given extremal
        Betti numbers configuration
      * tLastMon -- give the last t-spread monomial of the
        Borel shadow a given t-spread monomial
      * tLexIdeal -- returns the t-spread lex ideal with a
        given ft-vector or with the same ft-vector of a given t-strongly stable
        ideal
      * tLexMon -- give the smallest initial t-lex segment
        containing a given monomial
      * tLexSeg -- give the t-lex segment with given extremes
      * tMacaulayExpansion -- compute the t-Macaulay
        expansion of a positive integer
      * tNextMon -- give the t-lex successor of a given
        t-spread monomial
      * tPascalIdeal -- give the Pascal ideal of t-spread
        monomials of a given polynomial ring
      * tShadow -- give the t-spread shadow of a given t-spread
        monomial or a given list of t-spread monomials
      * tSpreadIdeal -- give the ideal generated by the
        t-spread monomials which are among the generators of a given ideal
      * tSpreadList -- give the set of all t-spread
        monomials of a given list
      * tStronglyStableIdeal -- give the smallest
        t-strongly stable ideal containing a given t-spread ideal
      * tStronglyStableMon -- give the t-strongly
        stable set generated by a given monomial
      * tStronglyStableSeg -- give the t-strongly
        stable segment with the given extremes
      * tVeroneseIdeal -- give the Veronese ideal of
        t-spread monomials of a given degree
      * tVeroneseSet -- give the Veronese set of t-spread
        monomials of a given degree
  * Methods
      * "countTLexMon(RingElement,ZZ)" -- see countTLexMon,
        -- give the cardinality of the smallest initial t-lex segment
        containing a given monomial
      * "countTStronglyStableMon(RingElement,ZZ)" -- see
        countTStronglyStableMon, -- give the
        cardinality of the t-strongly stable set generated by a given monomial
      * "fTVector(Ideal,ZZ)" -- see fTVector, -- compute the
        ft-vector of a given t-spread ideal of a polynomial ring
      * "initialDegree(Ideal)" -- see initialDegree, --
        return the initial degree of a given graded ideal
      * "initialIdeal(Ideal)" -- see initialIdeal, --
        return the initial ideal of a given ideal
      * "isFTVector(Ring,List,ZZ)" -- see isFTVector, --
        whether a given list of nonnegative integers is the ft-vector of a
        t-strongly stable ideal of a given polynomial ring
      * "isTLexIdeal(Ideal,ZZ)" -- see isTLexIdeal, --
        whether a given t-spread ideal is t-spread lex
      * "isTLexSeg(List,ZZ)" -- see isTLexSeg, -- whether a
        set of t-spread monomials is a t-lex segment
      * "isTSpread(Ideal,ZZ)" -- see isTSpread, -- whether a
        monomial, a list of monomials or a monomial ideal is t-spread
      * "isTSpread(List,ZZ)" -- see isTSpread, -- whether a
        monomial, a list of monomials or a monomial ideal is t-spread
      * "isTSpread(RingElement,ZZ)" -- see isTSpread, --
        whether a monomial, a list of monomials or a monomial ideal is t-spread
      * "isTStronglyStableIdeal(Ideal,ZZ)" -- see isTStronglyStableIdeal,
        -- whether a given t-spread ideal is t-strongly
        stable
      * "isTStronglyStableSeg(List,ZZ)" -- see isTStronglyStableSeg,
        -- whether the given list of t-spread monomials
        is a t-strongly stable segment
      * "minimalBettiNumbers(Ideal)" -- see minimalBettiNumbers,
        -- return the minimal Betti numbers of the
        quotient ring corresponding to a given graded ideal
      * "minimalBettiNumbersIdeal(Ideal)" -- see
        minimalBettiNumbersIdeal, -- return the
        minimal Betti numbers of a given graded ideal
      * "solveBinomialExpansion(List)" -- see solveBinomialExpansion,
        -- compute the sum of a binomial expansion
      * "tExtremalBettiCorners(Ideal,ZZ)" -- see tExtremalBettiCorners,
        -- give the corners of the extremal Betti
        numbers of a given t-strongly stable ideal
      * "tExtremalBettiMonomials(Ring,List,List,ZZ)" -- see
        tExtremalBettiMonomials, -- give the list of
        the t-spread basic monomials related to the given extremal Betti
        numbers configuration
      * "tLastMon(RingElement,ZZ,ZZ)" -- see tLastMon, -- give
        the last t-spread monomial of the Borel shadow a given t-spread
        monomial
      * "tLexIdeal(Ideal,ZZ)" -- see tLexIdeal, -- returns the
        t-spread lex ideal with a given ft-vector or with the same ft-vector of
        a given t-strongly stable ideal
      * "tLexIdeal(Ring,List,ZZ)" -- see tLexIdeal, -- returns
        the t-spread lex ideal with a given ft-vector or with the same
        ft-vector of a given t-strongly stable ideal
      * "tLexMon(RingElement,ZZ)" -- see tLexMon, -- give the
        smallest initial t-lex segment containing a given monomial
      * "tLexSeg(RingElement,RingElement,ZZ)" -- see tLexSeg, --
        give the t-lex segment with given extremes
      * "tMacaulayExpansion(ZZ,ZZ,ZZ,ZZ)" -- see tMacaulayExpansion,
        -- compute the t-Macaulay expansion of a positive
        integer
      * "tNextMon(RingElement,ZZ)" -- see tNextMon, -- give the
        t-lex successor of a given t-spread monomial
      * "tPascalIdeal(Ring,ZZ)" -- see tPascalIdeal, --
        give the Pascal ideal of t-spread monomials of a given polynomial ring
      * "tShadow(List,ZZ)" -- see tShadow, -- give the t-spread
        shadow of a given t-spread monomial or a given list of t-spread
        monomials
      * "tShadow(RingElement,ZZ)" -- see tShadow, -- give the
        t-spread shadow of a given t-spread monomial or a given list of
        t-spread monomials
      * "tSpreadIdeal(Ideal,ZZ)" -- see tSpreadIdeal, --
        give the ideal generated by the t-spread monomials which are among the
        generators of a given ideal
      * "tSpreadList(List,ZZ)" -- see tSpreadList, -- give
        the set of all t-spread monomials of a given list
      * "tStronglyStableIdeal(Ideal,ZZ)" -- see tStronglyStableIdeal,
        -- give the smallest t-strongly stable ideal
        containing a given t-spread ideal
      * "tStronglyStableMon(RingElement,ZZ)" -- see tStronglyStableMon,
        -- give the t-strongly stable set generated by a
        given monomial
      * "tStronglyStableSeg(RingElement,RingElement,ZZ)" -- see
        tStronglyStableSeg, -- give the t-strongly stable
        segment with the given extremes
      * "tVeroneseIdeal(Ring,ZZ,ZZ)" -- see tVeroneseIdeal,
        -- give the Veronese ideal of t-spread monomials of a
        given degree
      * "tVeroneseSet(Ring,ZZ,ZZ)" -- see tVeroneseSet, --
        give the Veronese set of t-spread monomials of a given degree
  * Symbols
      * FixedMax -- optional boolean argument for tNextMon
      * MaxInd -- optional integer argument for tLastMon
      * Shift -- optional boolean argument for tMacaulayExpansion

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

The object TSpreadIdeals, is a package (Macaulay2Doc).

T-spread managing

T-lex structures

T-strongly stable structures

Kruskal-Katona's Theorem

Extremal Betti numbers

Services

Options

tLastMon -- give the last t-spread monomial of the Borel shadow a given t-spread monomial
*****************************************************************************************

Synopsis
========

  * Usage:
        tLastMon(u,gap,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * gap, a positive integer representing the difference between the degrees
      * t, a positive integer that identifies the t-spread contest
  * Optional inputs (Macaulay2Doc),:
      * MaxInd, => ..., default value -1, optional integer
        argument for tLastMon
  * Outputs:
      * a ring element (Macaulay2Doc), the smallest t-spread
        monomial of the Borel shadow of u, with respect to lexcografic order

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

the function tLastMon(u,gap,t) gives the smallest t-spread monomials of the
Borel shadow iterated gaptimes of u, that is, the smallest monomial of
$B_\texttt{t}\{\texttt{u}\}$, with respect to $>_\mathrm{slex}.$
If MaxInd is greater than -1 the function tLastMon(u,gap,t,MaxInd=>m) gives the
smallest t-spread monomial for which the maximum of the support is m
The Borel shadow of a t-spread monomial u, is defined as the shadow of the
strongly stable set generated by u. To work in a t-spread contest, the Borel
shadow of u is the t-shadow of $B_\texttt{t}\{u\}$.

Examples:

+-----------------------------------------------+
|i1 : S=QQ[x_1..x_16]                           |
|                                               |
|o1 = S                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : tLastMon(x_2*x_6*x_10*x_13,1,3)           |
|                                               |
|o2 = x x x  x  x                               |
|      2 6 10 13 16                             |
|                                               |
|o2 : S                                         |
+-----------------------------------------------+
|i3 : tLastMon(x_2*x_6*x_10*x_13,1,3,MaxInd=>14)|
|                                               |
|o3 = x x x x  x                                |
|      2 5 8 11 14                              |
|                                               |
|o3 : S                                         |
+-----------------------------------------------+

See also
========

  * FixedMax -- optional boolean argument for tNextMon
  * tShadow -- give the t-spread shadow of a given t-spread
    monomial or a given list of t-spread monomials

Ways to use tLastMon:
=====================

  * "tLastMon(RingElement,ZZ,ZZ)"

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

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

tPascalIdeal -- give the Pascal ideal of t-spread monomials of a given polynomial ring
**************************************************************************************

Synopsis
========

  * Usage:
        tPascalIdeal(S,t)
  * Inputs:
      * S, a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * an ideal (Macaulay2Doc), the Pascal ideal of t-spread
        monomials of S

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

the function tPascalIdeal(S,t) returns the Pascal ideal of t-spread monomials
of S, that is, the ideal generated by the minimum number of t-spread monomials
of S with the greatest possible degrees and such that the supports of the
generators are pairwise disjoint.

Examples:

+----------------------------------------+
|i1 : S=QQ[x_1..x_10]                    |
|                                        |
|o1 = S                                  |
|                                        |
|o1 : PolynomialRing                     |
+----------------------------------------+
|i2 : tPascalIdeal(S,3)                  |
|                                        |
|o2 = ideal (x x x x  , x x x , x x x )  |
|             1 4 7 10   2 5 8   3 6 9   |
|                                        |
|o2 : Ideal of S                         |
+----------------------------------------+
|i3 : tPascalIdeal(S,4)                  |
|                                        |
|o3 = ideal (x x x , x x x  , x x , x x )|
|             1 5 9   2 6 10   3 7   4 8 |
|                                        |
|o3 : Ideal of S                         |
+----------------------------------------+

Ways to use tPascalIdeal:
=========================

  * "tPascalIdeal(Ring,ZZ)"

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

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

tSpreadList -- give the set of all t-spread monomials of a given list
*********************************************************************

Synopsis
========

  * Usage:
        tSpreadList(l,t)
  * Inputs:
      * l, a list of t-spread monomials of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the set of all the t-spread
        monomials belonging to l

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

the function tSpreadList(l,t) gives the list of all the t-spread monomials l.
This function calls the method isTSpread(u,t) to check whether the monomial u
is t-spread, for all the monomials that belong to the list l.
Let $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ a monomial of $S=K[x_1,\ldots,x_n]$, with
$1\le i_1\le i_2\le\dots\le i_d\le n$. The monomial u is called $t$-spread if
$i_{j+1}-i_j\ge t$ for all $j\in [d-1]$.

Examples:

+--------------------------------------------+
|i1 : S=QQ[x_1..x_14]                        |
|                                            |
|o1 = S                                      |
|                                            |
|o1 : PolynomialRing                         |
+--------------------------------------------+
|i2 : l={x_3*x_7*x_10*x_14, x_1*x_5*x_9*x_13}|
|                                            |
|o2 = {x x x  x  , x x x x  }                |
|       3 7 10 14   1 5 9 13                 |
|                                            |
|o2 : List                                   |
+--------------------------------------------+
|i3 : tSpreadList(l,4)                       |
|                                            |
|o3 = {x x x x  }                            |
|       1 5 9 13                             |
|                                            |
|o3 : List                                   |
+--------------------------------------------+
|i4 : tSpreadList(l,5)                       |
|                                            |
|o4 = {}                                     |
|                                            |
|o4 : List                                   |
+--------------------------------------------+

See also
========

  * tSpreadIdeal -- give the ideal generated by the
    t-spread monomials which are among the generators of a given ideal
  * isTSpread -- whether a monomial, a list of monomials or a
    monomial ideal is t-spread

Ways to use tSpreadList:
========================

  * "tSpreadList(List,ZZ)"

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

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

tSpreadIdeal -- give the ideal generated by the t-spread monomials which are among the generators of a given ideal
******************************************************************************************************************

Synopsis
========

  * Usage:
        tSpreadIdeal(I,t)
  * Inputs:
      * I, a graded ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * an ideal (Macaulay2Doc), the ideal generated by all the
        t-spread monomials belonging to the generator set of the ideal I

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

the function tSpreadIdeal(I,t) gives the ideal generated by all the t-spread
monomials which are among the generators of the ideal I.
This function calls the method tSpreadList(l,t) to sieve the t-spread monomials
from the list l, of the generators of the ideal I.
Let $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ a monomial of $S=K[x_1,\ldots,x_n]$, with
$1\le i_1\le i_2\le\dots\le i_d\le n$. The monomial u is called $t$-spread if
$i_{j+1}-i_j\ge t$ for all $j\in [d-1]$. A monomial ideal is called t-spread if
it is generated by t-spread monomials.

Examples:

+--------------------------------------------------+
|i1 : S=QQ[x_1..x_14]                              |
|                                                  |
|o1 = S                                            |
|                                                  |
|o1 : PolynomialRing                               |
+--------------------------------------------------+
|i2 : I=ideal {x_3*x_7*x_10*x_14, x_1*x_5*x_9*x_13}|
|                                                  |
|o2 = ideal (x x x  x  , x x x x  )                |
|             3 7 10 14   1 5 9 13                 |
|                                                  |
|o2 : Ideal of S                                   |
+--------------------------------------------------+
|i3 : tSpreadIdeal(I,3)                            |
|                                                  |
|o3 = ideal (x x x  x  , x x x x  )                |
|             3 7 10 14   1 5 9 13                 |
|                                                  |
|o3 : Ideal of S                                   |
+--------------------------------------------------+
|i4 : tSpreadIdeal(I,4)                            |
|                                                  |
|o4 = ideal(x x x x  )                             |
|            1 5 9 13                              |
|                                                  |
|o4 : Ideal of S                                   |
+--------------------------------------------------+

See also
========

  * tSpreadList -- give the set of all t-spread monomials
    of a given list
  * isTSpread -- whether a monomial, a list of monomials or a
    monomial ideal is t-spread

Ways to use tSpreadIdeal:
=========================

  * "tSpreadIdeal(Ideal,ZZ)"

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

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

isTSpread -- whether a monomial, a list of monomials or a monomial ideal is t-spread
************************************************************************************

Synopsis
========

  * Usage:
        isTSpread(u,t), isTSpread(l,t) or isTSpread(I,t)
  * Inputs:
      * u, a monomial of a polynomial ring
      * l, a list of monomials of a polynomial ring
      * I, a monomial ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether a given monomial
        u, a list of monomials l or a monomial ideal I is t-spread

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

the function isTSpread(-,t) has three overloading changing for the first
parameter. It checks whether a given monomial u, a list of monomials l or a
monomial ideal I is t-spread.
Let $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ a monomial of $S=K[x_1,\ldots,x_n]$, with
$1\le i_1\le i_2\le\dots\le i_d\le n$. The monomial u is called $t$-spread if
$i_{j+1}-i_j\ge t$ for all $j\in [d-1].$
A list of monomials is t-spread if all the monomials of the list are t-spread.
A monomial ideal is called t-spread if it is generated by t-spread monomials.

Examples:

+--------------------------------------------+
|i1 : S=QQ[x_1..x_14]                        |
|                                            |
|o1 = S                                      |
|                                            |
|o1 : PolynomialRing                         |
+--------------------------------------------+
|i2 : l={x_3*x_7*x_10*x_14, x_1*x_5*x_9*x_13}|
|                                            |
|o2 = {x x x  x  , x x x x  }                |
|       3 7 10 14   1 5 9 13                 |
|                                            |
|o2 : List                                   |
+--------------------------------------------+
|i3 : isTSpread(l#0,3)                       |
|                                            |
|o3 = true                                   |
+--------------------------------------------+
|i4 : isTSpread(l,3)                         |
|                                            |
|o4 = true                                   |
+--------------------------------------------+
|i5 : isTSpread(ideal l,3)                   |
|                                            |
|o5 = true                                   |
+--------------------------------------------+
|i6 : isTSpread(ideal l,4)                   |
|                                            |
|o6 = false                                  |
+--------------------------------------------+

Ways to use isTSpread:
======================

  * "isTSpread(Ideal,ZZ)"
  * "isTSpread(List,ZZ)"
  * "isTSpread(RingElement,ZZ)"

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

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

tShadow -- give the t-spread shadow of a given t-spread monomial or a given list of t-spread monomials
******************************************************************************************************

Synopsis
========

  * Usage:
        tShadow(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * l, a list of t-spread monomials of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the list of all the t-spread
        monomial of the shadow of the t-spread monomial u or of the list l

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

the function tShadow(u,t) gives the t-spread shadow of u, that is, the set of
all the t-spread monomials of the shadow of u. The overloading function
tShadow(l,t) gives the t-spread shadow of l, that is, the set of all the
t-spread monomials of the shadow of each t-spread monomial belonging to l.
Let $S=K[x_1,\ldots,x_n]$ and $u\in M_{n,d,t}$, that is, u is a $t$-spread
monomial of degree $d$. The t-spread shadow of u, is defined as
$\mathrm{Shad}_t(u)=\{ux_i\ :\ i\in [n]\}\cap M_{n,d+1,t}$. The algorithm is
optimized for the $t$-spread environment.

Examples:

+--------------------------------------------------------------+
|i1 : S=QQ[x_1..x_14]                                          |
|                                                              |
|o1 = S                                                        |
|                                                              |
|o1 : PolynomialRing                                           |
+--------------------------------------------------------------+
|i2 : u=x_2*x_6*x_10                                           |
|                                                              |
|o2 = x x x                                                    |
|      2 6 10                                                  |
|                                                              |
|o2 : S                                                        |
+--------------------------------------------------------------+
|i3 : tShadow(u,3)                                             |
|                                                              |
|o3 = {x x x  x  , x x x  x  }                                 |
|       2 6 10 13   2 6 10 14                                  |
|                                                              |
|o3 : List                                                     |
+--------------------------------------------------------------+
|i4 : tShadow(u,4)                                             |
|                                                              |
|o4 = {x x x  x  }                                             |
|       2 6 10 14                                              |
|                                                              |
|o4 : List                                                     |
+--------------------------------------------------------------+
|i5 : l={x_3*x_6*x_10, x_1*x_5*x_9}                            |
|                                                              |
|o5 = {x x x  , x x x }                                        |
|       3 6 10   1 5 9                                         |
|                                                              |
|o5 : List                                                     |
+--------------------------------------------------------------+
|i6 : tShadow(l,3)                                             |
|                                                              |
|o6 = {x x x x  , x x x x  , x x x x  , x x x  x  , x x x  x  }|
|       1 5 9 12   1 5 9 13   1 5 9 14   3 6 10 13   3 6 10 14 |
|                                                              |
|o6 : List                                                     |
+--------------------------------------------------------------+
|i7 : tShadow(l,4)                                             |
|                                                              |
|o7 = {x x x x  , x x x x  }                                   |
|       1 5 9 13   1 5 9 14                                    |
|                                                              |
|o7 : List                                                     |
+--------------------------------------------------------------+

See also
========

  * isTSpread -- whether a monomial, a list of monomials or a
    monomial ideal is t-spread

Ways to use tShadow:
====================

  * "tShadow(List,ZZ)"
  * "tShadow(RingElement,ZZ)"

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

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

tNextMon -- give the t-lex successor of a given t-spread monomial
*****************************************************************

Synopsis
========

  * Usage:
        tNextMon(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Optional inputs (Macaulay2Doc),:
      * FixedMax, => ..., default value false, optional boolean
        argument for tNextMon
  * Outputs:
      * a ring element (Macaulay2Doc), the greatest t-spread
        monomial less than u, with respect to lexcografic order

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

the function tNextMon(u,t) gives the t-lex successor of t, that is, the
greatest t-spread monomial less than u with respect to $>_\mathrm{slex}.$
If FixedMax is true the function tNextMon(u,t,FixedMax=>true) gives the t-lex
successor for which the maximum of the support is
$\max\textrm{supp}(\texttt{u}).$
Given a $t$-spread monomial $u=x_{i_1}x_{i_2}\cdots x_{i_d}$, we define
$\textrm{supp}(u)=\{i_1,i_2,\ldots, i_d\}$.

Examples:

+-------------------------------------------------+
|i1 : S=QQ[x_1..x_16]                             |
|                                                 |
|o1 = S                                           |
|                                                 |
|o1 : PolynomialRing                              |
+-------------------------------------------------+
|i2 : tNextMon(x_2*x_6*x_10*x_13,3)               |
|                                                 |
|o2 = x x x  x                                    |
|      2 6 10 14                                  |
|                                                 |
|o2 : S                                           |
+-------------------------------------------------+
|i3 : tNextMon(x_2*x_6*x_10*x_13,3,FixedMax=>true)|
|                                                 |
|o3 = x x x  x                                    |
|      2 7 10 13                                  |
|                                                 |
|o3 : S                                           |
+-------------------------------------------------+

See also
========

  * FixedMax -- optional boolean argument for tNextMon
  * tLexSeg -- give the t-lex segment with given extremes
  * tLexIdeal -- returns the t-spread lex ideal with a given
    ft-vector or with the same ft-vector of a given t-strongly stable ideal

Ways to use tNextMon:
=====================

  * "tNextMon(RingElement,ZZ)"

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

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

tLexSeg -- give the t-lex segment with given extremes
*****************************************************

Synopsis
========

  * Usage:
        tLexSeg(v,u,t)
  * Inputs:
      * v, a t-spread monomial of a polynomial ring
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the set of all the t-spread
        monomials smaller than v and greater than u, with respect to
        lexcografic order

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

the function tLexSeg(v,u,t) gives the t-lex segment defined by v and u, that
is, the set of all the t-spread monomials smaller than v and greater than u,
with respect to $>_\mathrm{slex}.$
This function iteratively uses the method tNextMon(u,t) until the returned
monomial is u.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_14]                                                         |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tLexSeg(x_2*x_5*x_10*x_13,x_2*x_6*x_9*x_12,2)                           |
|                                                                             |
|o2 = {x x x  x  , x x x  x  , x x x  x  , x x x  x  , x x x  x  , x x x x  , |
|       2 5 10 13   2 5 10 14   2 5 11 13   2 5 11 14   2 5 12 14   2 6 8 10  |
|     ------------------------------------------------------------------------|
|     x x x x  , x x x x  , x x x x  , x x x x  , x x x x  , x x x x  }       |
|      2 6 8 11   2 6 8 12   2 6 8 13   2 6 8 14   2 6 9 11   2 6 9 12        |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : tLexSeg(x_2*x_5*x_10*x_13,x_2*x_6*x_9*x_12,3)                           |
|                                                                             |
|o3 = {x x x  x  , x x x  x  , x x x  x  , x x x x  }                         |
|       2 5 10 13   2 5 10 14   2 5 11 14   2 6 9 12                          |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * tNextMon -- give the t-lex successor of a given t-spread
    monomial
  * tLexIdeal -- returns the t-spread lex ideal with a given
    ft-vector or with the same ft-vector of a given t-strongly stable ideal

Ways to use tLexSeg:
====================

  * "tLexSeg(RingElement,RingElement,ZZ)"

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

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

isTLexSeg -- whether a set of t-spread monomials is a t-lex segment
*******************************************************************

Synopsis
========

  * Usage:
        isTLexSeg(l,t)
  * Inputs:
      * l, a list of t-spread monomials of a polynomial ring
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the list l of
        monomials is a t-lex segment

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

the function isTLexSeg(l,t) is true whether the list of monomials l is a t-lex
segment, that is, the set of all the t-spread monomials smaller than the
maximum of l and greater than the minimum of l, with respect to
$>_\mathrm{slex}.$

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_7]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : isTLexSeg({x_1*x_4*x_7,x_1*x_5*x_7,x_2*x_4*x_6,x_2*x_4*x_7,x_2*x_5*x_7},|
|                                                                             |
|o2 = true                                                                    |
|-----------------------------------------------------------------------------|
|2)                                                                           |
+-----------------------------------------------------------------------------+
|i3 : isTLexSeg({x_1*x_4*x_7,x_2*x_4*x_6,x_2*x_4*x_7,x_2*x_5*x_7},2)          |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * tLexSeg -- give the t-lex segment with given extremes
  * tNextMon -- give the t-lex successor of a given t-spread
    monomial

Ways to use isTLexSeg:
======================

  * "isTLexSeg(List,ZZ)"

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

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

tLexMon -- give the smallest initial t-lex segment containing a given monomial
******************************************************************************

Synopsis
========

  * Usage:
        tLexMon(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the set of all the t-spread
        monomials greater than u, with respect to lexcografic order

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

the function tLexMon(u,t) gives the initial t-lex segment defined by u, that
is, the set of all the t-spread monomials greater than u, with respect to
$>_\mathrm{slex}.$
This function calls the method tLexSeg(v,u,t), where v is the greatest t-spread
monomial of the polynomial ring. Let $S=K[x_1,\ldots,x_n]$ and $u\in
M_{n,d,t}$, then $v=x_1x_{1+t}\cdots x_{1+(d-1)t}$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_9]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tLexMon(x_2*x_5*x_8,2)                                                  |
|                                                                             |
|o2 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x ,|
|       1 3 5   1 3 6   1 3 7   1 3 8   1 3 9   1 4 6   1 4 7   1 4 8   1 4 9 |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , |
|      1 5 7   1 5 8   1 5 9   1 6 8   1 6 9   1 7 9   2 4 6   2 4 7   2 4 8  |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x }                                                 |
|      2 4 9   2 5 7   2 5 8                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : tLexMon(x_2*x_5*x_8,3)                                                  |
|                                                                             |
|o3 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x }                |
|       1 4 7   1 4 8   1 4 9   1 5 8   1 5 9   1 6 9   2 5 8                 |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * tNextMon -- give the t-lex successor of a given t-spread
    monomial
  * tLexSeg -- give the t-lex segment with given extremes
  * isTLexSeg -- whether a set of t-spread monomials is a
    t-lex segment

Ways to use tLexMon:
====================

  * "tLexMon(RingElement,ZZ)"

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

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

countTLexMon -- give the cardinality of the smallest initial t-lex segment containing a given monomial
******************************************************************************************************

Synopsis
========

  * Usage:
        countTLexMon(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Optional inputs (Macaulay2Doc),:
      * FixedMax, => ..., default value false, optional boolean
        argument for tNextMon
  * Outputs:
      * an integer (Macaulay2Doc), the number of all the t-spread
        monomials greater than u, with respect to lexcografic order

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

the function countTLexMon(u,t) gives the cardinality of $L_t\{u\}$, the initial
t-lex segment defined by u, that is, the number of all the t-spread monomials
greater than u, with respect to $>_\mathrm{slex}.$
If FixedMax is true the function countTLexMon(u,t,FixedMax=>true) gives the
number of all the t-spread monomials having maximum of the support equal to
$\max\textrm{supp}(u)$ and greater than u, with respect to $>_\mathrm{slex}.$
Given a $t$-spread monomial $u=x_{i_1}x_{i_2}\cdots x_{i_d}$, we define
$\textrm{supp}(u)=\{i_1,i_2,\ldots, i_d\}$.
This method is not constructive. It uses a theoretical result to obtain the
cardinality as the sum of suitable binomial coefficients. The procedure only
concerns $\textrm{supp}(\texttt{u}),$ that is, the set $\{i_1,i_2,\ldots,
i_d\}$, when $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ is a $t$-spread monomial.

Examples:

+--------------------------------+
|i1 : S=QQ[x_1..x_9]             |
|                                |
|o1 = S                          |
|                                |
|o1 : PolynomialRing             |
+--------------------------------+
|i2 : countTLexMon(x_2*x_5*x_8,2)|
|                                |
|o2 = 21                         |
+--------------------------------+
|i3 : countTLexMon(x_2*x_5*x_8,3)|
|                                |
|o3 = 7                          |
+--------------------------------+

See also
========

  * tLexMon -- give the smallest initial t-lex segment
    containing a given monomial

Ways to use countTLexMon:
=========================

  * "countTLexMon(RingElement,ZZ)"

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

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

tVeroneseSet -- give the Veronese set of t-spread monomials of a given degree
*****************************************************************************

Synopsis
========

  * Usage:
        tVeroneseSet(S,d,t)
  * Inputs:
      * S, a polynomial ring
      * d, a nonnegative integer that identifies the degree of the monomials
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the set of all the t-spread
        monomials of S of degree d

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

the function tVeroneseSet(S,d,t) gives the Veronese set of t-spread monomials
of degree d, that is, the set of all the t-spread monomials of S of degree
dThis function calls the method tLexSeg(v,u,t), where v is the greatest
t-spread monomial of the polynomial ring and u the smallest one. If
$S=K[x_1,\ldots,x_n]$ then $v=x_1x_{1+t}\cdots x_{1+(d-1)t}$ and
$u=x_{n-(d-1)t}\cdots x_{n-t} x_{n}$. This set is also denoted by $M_{n,d,t}$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_8]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tVeroneseSet(S,3,2)                                                     |
|                                                                             |
|o2 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x ,|
|       1 3 5   1 3 6   1 3 7   1 3 8   1 4 6   1 4 7   1 4 8   1 5 7   1 5 8 |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , |
|      1 6 8   2 4 6   2 4 7   2 4 8   2 5 7   2 5 8   2 6 8   3 5 7   3 5 8  |
|     ------------------------------------------------------------------------|
|     x x x , x x x }                                                         |
|      3 6 8   4 6 8                                                          |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : tVeroneseSet(S,3,3)                                                     |
|                                                                             |
|o3 = {x x x , x x x , x x x , x x x }                                        |
|       1 4 7   1 4 8   1 5 8   2 5 8                                         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * tNextMon -- give the t-lex successor of a given t-spread
    monomial
  * tLexSeg -- give the t-lex segment with given extremes
  * isTLexSeg -- whether a set of t-spread monomials is a
    t-lex segment
  * tLexMon -- give the smallest initial t-lex segment
    containing a given monomial
  * tVeroneseIdeal -- give the Veronese ideal of
    t-spread monomials of a given degree

Ways to use tVeroneseSet:
=========================

  * "tVeroneseSet(Ring,ZZ,ZZ)"

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

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

tVeroneseIdeal -- give the Veronese ideal of t-spread monomials of a given degree
*********************************************************************************

Synopsis
========

  * Usage:
        tVeroneseIdeal(S,d,t)
  * Inputs:
      * S, a polynomial ring
      * d, a nonnegative integer that identifies the degree of the monomials
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * an ideal (Macaulay2Doc), the ideal generated by all the
        t-spread monomials of S of degree d

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

the function tVeroneseIdeal(S,d,t) returns the Veronese ideal of t-spread
monomials of degree d, that is, the ideal generated by all the t-spread
monomials of S of degree dThis function calls the method tVeroneseSet(S,d,t).

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_8]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tVeroneseIdeal(S,3,2)                                                   |
|                                                                             |
|o2 = ideal (x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x ,  |
|             1 3 5   1 3 6   1 3 7   1 3 8   1 4 6   1 4 7   1 4 8   1 5 7   |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , |
|      1 5 8   1 6 8   2 4 6   2 4 7   2 4 8   2 5 7   2 5 8   2 6 8   3 5 7  |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x )                                                 |
|      3 5 8   3 6 8   4 6 8                                                  |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : tVeroneseIdeal(S,3,4)                                                   |
|                                                                             |
|o3 = ideal 0                                                                 |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * tNextMon -- give the t-lex successor of a given t-spread
    monomial
  * tLexSeg -- give the t-lex segment with given extremes
  * isTLexSeg -- whether a set of t-spread monomials is a
    t-lex segment
  * tLexMon -- give the smallest initial t-lex segment
    containing a given monomial
  * tVeroneseSet -- give the Veronese set of t-spread
    monomials of a given degree

Ways to use tVeroneseIdeal:
===========================

  * "tVeroneseIdeal(Ring,ZZ,ZZ)"

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

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

isTLexIdeal -- whether a given t-spread ideal is t-spread lex
*************************************************************

Synopsis
========

  * Usage:
        isTLexIdeal(I,t)
  * Inputs:
      * I, a t-spread ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the ideal I is
        t-spread lex

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

Let $\texttt{S}=K[x_1,\ldots,x_n]$, $\texttt{t}\geq 1$ and a t-spread ideal I.
Then I is called a t-lex ideal, if $[I_j]_t$ is a t-spread lex set for all $j$.
We recall that $[I_j]_t$ is the t-spread part of the $j$-th graded component of
I. Moreover, a subset $L\subset M_{n,d,t}$ is called a t-lex set if for all
$u\in L$ and for all $v\in M_{n,d,t}$ with $v>_\mathrm{slex} u$, it follows
that $u\in L$.

Examples:

+---------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_6]                                                        |
|                                                                           |
|o1 = S                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : isTLexIdeal(ideal {x_1*x_3,x_1*x_5},2)                                |
|                                                                           |
|o2 = false                                                                 |
+---------------------------------------------------------------------------+
|i3 : isTLexIdeal(ideal {x_1*x_3,x_1*x_4,x_1*x_5,x_1*x_6,x_2*x_4,x_2*x_5},2)|
|                                                                           |
|o3 = true                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * tLexIdeal -- returns the t-spread lex ideal with a given
    ft-vector or with the same ft-vector of a given t-strongly stable ideal

Ways to use isTLexIdeal:
========================

  * "isTLexIdeal(Ideal,ZZ)"

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

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

tStronglyStableSeg -- give the t-strongly stable segment with the given extremes
********************************************************************************

Synopsis
========

  * Usage:
        tStronglyStableSeg(v,u,t)
  * Inputs:
      * v, a t-spread monomial of a polynomial ring
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the set of all the t-spread
        monomials of the t-stromgly stable set generated by u and smaller than
        u, with respect to lexcografic order

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

the function tStronglyStableSeg(v,u,t) gives the set of t-spread monomials
belonging to the strongly stable set generated by u and smaller than v, that
is, $B_t[v,u]=\{w\in B_t\{u\}\ :\ v\geq_\mathrm{slex} w\}.$
We recall that if $u\in M_{n,d,t}\subset S=K[x_1,\ldots,x_n]$ then $B_t\{u\}$
is the smallest t-strongly stable set of monomials of $M_{n,d,t}$ containing
$u.$
Moreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_14]                                                         |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tStronglyStableSeg(x_2*x_5*x_9*x_12,x_2*x_6*x_10*x_13,2)                |
|                                                                             |
|o2 = {x x x x  , x x x x  , x x x  x  , x x x  x  , x x x x  , x x x x  ,    |
|       2 5 9 12   2 5 9 13   2 5 10 12   2 5 10 13   2 6 8 10   2 6 8 11     |
|     ------------------------------------------------------------------------|
|     x x x x  , x x x x  , x x x x  , x x x x  , x x x x  , x x x  x  ,      |
|      2 6 8 12   2 6 8 13   2 6 9 11   2 6 9 12   2 6 9 13   2 6 10 12       |
|     ------------------------------------------------------------------------|
|     x x x  x  }                                                             |
|      2 6 10 13                                                              |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : tStronglyStableSeg(x_2*x_5*x_9*x_12,x_2*x_6*x_10*x_13,3)                |
|                                                                             |
|o3 = {x x x x  , x x x x  , x x x  x  , x x x x  , x x x x  , x x x  x  }    |
|       2 5 9 12   2 5 9 13   2 5 10 13   2 6 9 12   2 6 9 13   2 6 10 13     |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * isTStronglyStableSeg -- whether the given list
    of t-spread monomials is a t-strongly stable segment
  * tStronglyStableMon -- give the t-strongly stable
    set generated by a given monomial

Ways to use tStronglyStableSeg:
===============================

  * "tStronglyStableSeg(RingElement,RingElement,ZZ)"

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

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

isTStronglyStableSeg -- whether the given list of t-spread monomials is a t-strongly stable segment
***************************************************************************************************

Synopsis
========

  * Usage:
        isTStronglyStableSeg(l,t)
  * Inputs:
      * l, a list of t-spread monomials of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the list l of
        t-spread monomials is a t-strongly stable segment

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

the function isTStronglyStableSeg(l,t) is true whether the list of monomials l
is a t-strongly stable segment, that is, the set of all the t-spread monomials
belonging to the strongly stable set generated by the smallest monomial of l
and smaller than the greatest monomial of l, with respect to $>_\mathrm{slex}.$
In other words, whether $l=B_t[\max l,\min l]=\{w\in B_t\{\min l\}\ :\ \max
l\geq_\mathrm{slex} w\}.$
We recall that if $u\in M_{n,d,t}\subset S=K[x_1,\ldots,x_n]$ then $B_t\{u\}$
is the smallest t-strongly stable set of monomials of $M_{n,d,t}$ containing
$u.$
Moreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_9]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : isTStronglyStableSeg({x_1*x_4*x_7,x_1*x_4*x_8,x_1*x_5*x_8,x_2*x_5*x_8},3|
|                                                                             |
|o2 = true                                                                    |
|-----------------------------------------------------------------------------|
|)                                                                            |
+-----------------------------------------------------------------------------+
|i3 : isTStronglyStableSeg({x_1*x_4*x_7,x_1*x_4*x_8,x_2*x_5*x_8},3)           |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * tStronglyStableSeg -- give the t-strongly stable
    segment with the given extremes
  * tStronglyStableMon -- give the t-strongly stable
    set generated by a given monomial

Ways to use isTStronglyStableSeg:
=================================

  * "isTStronglyStableSeg(List,ZZ)"

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

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

tStronglyStableMon -- give the t-strongly stable set generated by a given monomial
**********************************************************************************

Synopsis
========

  * Usage:
        tStronglyStableMon(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the list of all the t-spread
        monomials of the t-strongly stable set generated by u

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

the function tStronglyStableMon(u,t) gives the list of all the monomials
belonging to the t-strongly stable set generated by u, that is, $B_t\{u\}.$
We recall that if $u\in M_{n,d,t}\subset S=K[x_1,\ldots,x_n]$ then $B_t\{u\}$
is the smallest t-strongly stable set of monomials of $M_{n,d,t}$ containing
$u.$
Moreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_9]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tStronglyStableMon(x_2*x_5*x_8,2)                                       |
|                                                                             |
|o2 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x ,|
|       1 3 5   1 3 6   1 3 7   1 3 8   1 4 6   1 4 7   1 4 8   1 5 7   1 5 8 |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x , x x x }                                 |
|      2 4 6   2 4 7   2 4 8   2 5 7   2 5 8                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : tStronglyStableMon(x_2*x_5*x_8,3)                                       |
|                                                                             |
|o3 = {x x x , x x x , x x x , x x x }                                        |
|       1 4 7   1 4 8   1 5 8   2 5 8                                         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * isTStronglyStableSeg -- whether the given list
    of t-spread monomials is a t-strongly stable segment
  * tStronglyStableMon -- give the t-strongly stable
    set generated by a given monomial

Ways to use tStronglyStableMon:
===============================

  * "tStronglyStableMon(RingElement,ZZ)"

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

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

countTStronglyStableMon -- give the cardinality of the t-strongly stable set generated by a given monomial
**********************************************************************************************************

Synopsis
========

  * Usage:
        countTStronglyStableMon(u,t)
  * Inputs:
      * u, a t-spread monomial of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * an integer (Macaulay2Doc), the number of all the t-spread
        monomials of the t-strongly stable set generated by u

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

the function countTStronglyStableMon(u,t) gives the cardinality of $B_t\{u\}$,
the t-strongly stable set generated by u, that is, the number of all the
t-spread monomials belonging to the smallest t-strongly stable set containing u
This method is not constructive. It uses a theoretical result to obtain the
cardinality as the sum of suitable binomial coefficients. The procedure only
concerns $\textrm{supp}(\texttt{u}),$ that is, the set $\{i_1,i_2,\ldots,
i_d\}$, when $u=x_{i_1}x_{i_2}\cdots x_{i_d}$ is a $t$-spread monomial.
Moreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.

Examples:

+-------------------------------------------+
|i1 : S=QQ[x_1..x_9]                        |
|                                           |
|o1 = S                                     |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : countTStronglyStableMon(x_2*x_5*x_8,2)|
|                                           |
|o2 = 14                                    |
+-------------------------------------------+
|i3 : countTStronglyStableMon(x_2*x_5*x_8,3)|
|                                           |
|o3 = 4                                     |
+-------------------------------------------+

See also
========

  * tStronglyStableMon -- give the t-strongly stable
    set generated by a given monomial

Ways to use countTStronglyStableMon:
====================================

  * "countTStronglyStableMon(RingElement,ZZ)"

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

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

tStronglyStableIdeal -- give the smallest t-strongly stable ideal containing a given t-spread ideal
***************************************************************************************************

Synopsis
========

  * Usage:
        tStronglyStableIdeal(I,t)
  * Inputs:
      * I, a t-spread ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the smallest t-strongly stable ideal
        containing the t-spread ideal I

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

the function tStronglyStableIdeal(I,t) gives the smallest t-strongly stable
ideal containing I, that is, $B_t(G(I))$ where $G(I)$ is the minimal set of
generators of $I$
We recall that if $u\in M_{n,d,t}\subset S=K[x_1,\ldots,x_n]$ then $B_t(u)$ is
the smallest t-strongly stable ideal of $S$ containing $u.$
Moreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.
A t-spread monomial ideal I is t-strongly stable if $[I_j]_t$ is a t-strongly
stable set for all $j$, where $[I_j]_t$ is the t-spread part of the $j$-th
graded component of I.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_9]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : tStronglyStableIdeal(ideal {x_2*x_5*x_8},2)                             |
|                                                                             |
|o2 = ideal (x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x ,  |
|             1 3 5   1 3 6   1 3 7   1 4 6   1 3 8   1 4 7   2 4 6   1 4 8   |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x , x x x , x x x )                         |
|      1 5 7   2 4 7   1 5 8   2 4 8   2 5 7   2 5 8                          |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : tStronglyStableIdeal(ideal {x_2*x_5*x_8},3)                             |
|                                                                             |
|o3 = ideal (x x x , x x x , x x x , x x x )                                  |
|             1 4 7   1 4 8   1 5 8   2 5 8                                   |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * isTStronglyStableSeg -- whether the given list
    of t-spread monomials is a t-strongly stable segment
  * tStronglyStableMon -- give the t-strongly stable
    set generated by a given monomial

Ways to use tStronglyStableIdeal:
=================================

  * "tStronglyStableIdeal(Ideal,ZZ)"

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

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

isTStronglyStableIdeal -- whether a given t-spread ideal is t-strongly stable
*****************************************************************************

Synopsis
========

  * Usage:
        isTStronglyStableIdeal(I,t)
  * Inputs:
      * I, a t-spread ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the ideal I is
        t-spread lex

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

Let $\texttt{S}=K[x_1,\ldots,x_n]$, $\texttt{t}\geq 1$ and a t-spread ideal I.
Then I is called a t-strongly stable ideal, if $[I_j]_t$ is a t-strongly stable
set for all $j$.
We recall that $[I_j]_t$ is the t-spread part of the $j$-th graded component of
IMoreover, a subset $N\subset M_{n,d,t}$ is called a t-strongly stable set if
taking a t-spread monomial $u\in N$, for all $j\in \mathrm{supp}(u)$ and all
$i,\ 1\leq i\leq j$, such that $x_i(u/x_j)$ is a t-spread monomial, then it
follows that $x_i(u/x_j)\in N$.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_6]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : isTStronglyStableIdeal(ideal {x_1*x_3,x_1*x_5},2)                       |
|                                                                             |
|o2 = false                                                                   |
+-----------------------------------------------------------------------------+
|i3 : isTStronglyStableIdeal(ideal                                            |
|                                                                             |
|o3 = true                                                                    |
|-----------------------------------------------------------------------------|
|{x_1*x_3,x_1*x_4,x_1*x_5,x_2*x_4,x_2*x_5},2)                                 |
+-----------------------------------------------------------------------------+

See also
========

  * tStronglyStableIdeal -- give the smallest
    t-strongly stable ideal containing a given t-spread ideal

Ways to use isTStronglyStableIdeal:
===================================

  * "isTStronglyStableIdeal(Ideal,ZZ)"

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

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

tMacaulayExpansion -- compute the t-Macaulay expansion of a positive integer
****************************************************************************

Synopsis
========

  * Usage:
        tMacaulayExpansion(a,n,d,t)
  * Inputs:
      * a, a positive integer to be expanded
      * n, a positive integer that identifies the number of indeterminates
      * d, a positive integer that identifies the degree
      * t, a positive integer that identifies the t-spread contest
  * Optional inputs (Macaulay2Doc),:
      * Shift, => ..., default value false, optional boolean
        argument for tMacaulayExpansion
  * Outputs:
      * a list (Macaulay2Doc), pairs of positive integers
        representing the d-th (shifted) t-Macaulay expansion of a with a given
        n

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

Given four positive integers (a,n,d,t) there is a unique expression of a as a
sum of binomials $a=\binom{a_d}{d} + \binom{a_{d-1}}{d-1} + \cdots +
\binom{a_j}{j}.$ where $a_i > a_{i-1} > \cdots > a_j > j >= 1.$
If the optional parameter Shift is true, then the method
tMacaulayExpansion(a,n,d,t,Shift=>true) returns the shifted t-Macaulay
expansion of a, that is, $a^{(d)}=\binom{a_d}{d+1} + \binom{a_{d-1}}{d} +
\cdots + \binom{a_j}{j+1}.$To obtain the sum of the binomial coefficients
represented in the output list, one can use the method solveBinomialExpansion.

Examples:

+----------------------------------------------+
|i1 : tMacaulayExpansion(50,12,2,1)            |
|                                              |
|o1 = {{10, 2}, {5, 1}}                        |
|                                              |
|o1 : List                                     |
+----------------------------------------------+
|i2 : tMacaulayExpansion(50,12,2,1,Shift=>true)|
|                                              |
|o2 = {{10, 3}, {5, 2}}                        |
|                                              |
|o2 : List                                     |
+----------------------------------------------+
|i3 : tMacaulayExpansion(50,12,2,2,Shift=>true)|
|                                              |
|o3 = {{9, 3}, {4, 2}}                         |
|                                              |
|o3 : List                                     |
+----------------------------------------------+

See also
========

  * solveBinomialExpansion -- compute the sum of
    a binomial expansion
  * isFTVector -- whether a given list of nonnegative
    integers is the ft-vector of a t-strongly stable ideal of a given
    polynomial ring
  * Shift -- optional boolean argument for tMacaulayExpansion

Ways to use tMacaulayExpansion:
===============================

  * "tMacaulayExpansion(ZZ,ZZ,ZZ,ZZ)"

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

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

fTVector -- compute the ft-vector of a given t-spread ideal of a polynomial ring
********************************************************************************

Synopsis
========

  * Usage:
        fTVector(I,t)
  * Inputs:
      * I, a t-spread ideal of polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), a list of nonnegative integers
        representing the ft-vector of the t-spread ideal I

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

Let I be a t-spread ideal of the polynomial ring $S=K[x_1,\ldots,x_n]$ One can
define the $f_\texttt{t}$-vector of I as $f_\texttt{t}(\texttt{I})=\left(
f_{\texttt{t},-1}(\texttt{I}), f_{\texttt{t},0}(\texttt{I}), \ldots,
f_{\texttt{t},j}(\texttt{I}), \ldots \right),$
where $f_{\texttt{t},j-1}(\texttt{I})=|[S_j]_t|-|[I_j]_t|$ and $[I_j]_t$ is the
t-spread part of the $j$-th graded component of I.
In an equivalent way, let $\Delta$ be the associated simplicial complex of I.
So, $f_{\texttt{t},j}(\texttt{I})$ is the cardinality of the set $\left\{F\ :\
F \text{ is a } j \text{-dimensional face in } \Delta \text{ and }
x_F=\prod_{i\in F}{x_i} \text{ is a } t \text{-spread monomial}\right\}.$

Example:

+--------------------------------------------+
|i1 : S=QQ[x_1..x_8]                         |
|                                            |
|o1 = S                                      |
|                                            |
|o1 : PolynomialRing                         |
+--------------------------------------------+
|i2 : fTVector(ideal {x_1*x_3,x_2*x_5*x_7},1)|
|                                            |
|o2 = {1, 8, 27, 49, 50, 27, 6, 0, 0}        |
|                                            |
|o2 : List                                   |
+--------------------------------------------+
|i3 : fTVector(ideal {x_1*x_3,x_2*x_5*x_7},2)|
|                                            |
|o3 = {1, 8, 20, 15, 2}                      |
|                                            |
|o3 : List                                   |
+--------------------------------------------+

See also
========

  * isFTVector -- whether a given list of nonnegative
    integers is the ft-vector of a t-strongly stable ideal of a given
    polynomial ring

Ways to use fTVector:
=====================

  * "fTVector(Ideal,ZZ)"

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

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

isFTVector -- whether a given list of nonnegative integers is the ft-vector of a t-strongly stable ideal of a given polynomial ring
***********************************************************************************************************************************

Synopsis
========

  * Usage:
        isFTVector(S,f,t)
  * Inputs:
      * S, a polynomial ring
      * f, a list of nonnegative integers
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the list f
        represents the ft-vector of a t-strongly stable ideal of S

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

Let $\texttt{S}=K[x_1,\ldots,x_n]$, $\texttt{t}\geq 1$ and let
$\texttt{f}=(f(0),f(1),\ldots,f(d),\ldots)$ be a sequence of nonnegative
integers. The sequence f is the $\texttt{f}_\texttt{t}$-vector of a t-spread
ideal of S if the following conditions hold:
$f(0)\leq 1,\ f(1)\leq n \text{ and } f(d+1)\leq
\texttt{tMacaulayExpansion(f(d),n,d,t,Shift=>true)}$ for all $d>1.$
Let I be a t-spread ideal of the polynomial ring $S=K[x_1,\ldots,x_n]$ One can
define the $f_\texttt{t}$-vector of I as $f_\texttt{t}(\texttt{I})=\left(
f_{\texttt{t},-1}(\texttt{I}), f_{\texttt{t},0}(\texttt{I}), \ldots,
f_{\texttt{t},j}(\texttt{I}), \ldots \right),$
where $f_{\texttt{t},j-1}(\texttt{I})=|[S_j]_t|-|[I_j]_t|$ and $[I_j]_t$ is the
t-spread part of the $j$-th graded component of I.

Example:

+----------------------+
|i1 : S=QQ[x_1..x_8]   |
|                      |
|o1 = S                |
|                      |
|o1 : PolynomialRing   |
+----------------------+
|i2 : f={1,8,20,10,0}  |
|                      |
|o2 = {1, 8, 20, 10, 0}|
|                      |
|o2 : List             |
+----------------------+
|i3 : isFTVector(S,f,2)|
|                      |
|o3 = true             |
+----------------------+
|i4 : S=QQ[x_1..x_7]   |
|                      |
|o4 = S                |
|                      |
|o4 : PolynomialRing   |
+----------------------+
|i5 : isFTVector(S,f,2)|
|                      |
|o5 = false            |
+----------------------+

See also
========

  * fTVector -- compute the ft-vector of a given t-spread
    ideal of a polynomial ring
  * tMacaulayExpansion -- compute the t-Macaulay
    expansion of a positive integer
  * solveBinomialExpansion -- compute the sum of
    a binomial expansion

Ways to use isFTVector:
=======================

  * "isFTVector(Ring,List,ZZ)"

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

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

tLexIdeal -- returns the t-spread lex ideal with a given ft-vector or with the same ft-vector of a given t-strongly stable ideal
********************************************************************************************************************************

Synopsis
========

  * Usage:
        tLexIdeal(S,f,t) or tLexIdeal(I,t)
  * Inputs:
      * S, a polynomial ring
      * f, a sequence of nonnegative integers
      * I, a t-strongly stable ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * an ideal (Macaulay2Doc), the t-spread lex ideal with
        ft-vector f or the t-spread lex ideal with the same ft-vector of I

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

It has been proved that if I is a t-strongly stable ideal then a unique t-lex
ideal with the same $f_\texttt{t}$-vector of I exists.
Let $\texttt{S}=K[x_1,\ldots,x_n]$, $\texttt{t}\geq 1$. The method
tLexIdeal(S,f,t) gives the t-lex ideal of S with f as $f_\texttt{t}$-vector, if
exists. The overloading method tLexIdeal(I,t) gives the t-lex ideal with the
same $f_\texttt{t}$-vector of the t-strongly stable ideal I.

Examples:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_8]                                                          |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f={1,8,2,0,0}                                                           |
|                                                                             |
|o2 = {1, 8, 2, 0, 0}                                                         |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : I=tLexIdeal(S,f,2)                                                      |
|                                                                             |
|o3 = ideal (x x , x x , x x , x x , x x , x x , x x , x x , x x , x x , x x ,|
|             1 3   1 4   2 4   1 5   2 5   3 5   1 6   2 6   3 6   4 6   1 7 |
|     ------------------------------------------------------------------------|
|     x x , x x , x x , x x , x x , x x , x x , x x )                         |
|      2 7   3 7   4 7   5 7   1 8   2 8   3 8   4 8                          |
|                                                                             |
|o3 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i4 : fTVector(I,2)==f                                                        |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+
|i5 : isTLexIdeal(I,2)                                                        |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+
|i6 : J=tStronglyStableIdeal(ideal {x_1*x_4*x_6},2)                           |
|                                                                             |
|o6 = ideal (x x x , x x x , x x x )                                          |
|             1 3 5   1 3 6   1 4 6                                           |
|                                                                             |
|o6 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i7 : K=tLexIdeal(J,2)                                                        |
|                                                                             |
|o7 = ideal (x x x , x x x , x x x , x x x x )                                |
|             1 3 5   1 3 6   1 3 7   1 4 6 8                                 |
|                                                                             |
|o7 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i8 : fTVector(J,2)==fTVector(K,2)                                            |
|                                                                             |
|o8 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * isTLexIdeal -- whether a given t-spread ideal is
    t-spread lex
  * fTVector -- compute the ft-vector of a given t-spread
    ideal of a polynomial ring
  * isFTVector -- whether a given list of nonnegative
    integers is the ft-vector of a t-strongly stable ideal of a given
    polynomial ring
  * isTStronglyStableIdeal -- whether a given
    t-spread ideal is t-strongly stable

Ways to use tLexIdeal:
======================

  * "tLexIdeal(Ideal,ZZ)"
  * "tLexIdeal(Ring,List,ZZ)"

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

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

tExtremalBettiCorners -- give the corners of the extremal Betti numbers of a given t-strongly stable ideal
**********************************************************************************************************

Synopsis
========

  * Usage:
        tExtremalBettiCorners(I,t)
  * Inputs:
      * I, a t-strongly stable graded ideal of a polynomial ring
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the corners of the extremal Betti
        numbers of the ideal I

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

let $S=K[x_1,\ldots,x_n]$ be a polynomial ring over a field $K$ and let I a
graded ideal of $S$. A graded Betti number of the ideal $\beta_{k,k+\ell}(I)\ne
0$ is called extremal if $\beta_{i,i+j}(I)=0$ for all $i\ge
k,j\ge\ell,(i,j)\ne(k,\ell).$
Let $\beta_{k,k+\ell}(I)$ be an extremal Betti number of I, the pair $(k,\ell)$
is called a corner of I. If $(k_1,\ell_1),\dots,(k_r,\ell_r)$, with $n-1\ge
k_1>k_2>\dots>k_r\ge1 \text{ and } 1\le \ell_1<\ell_2<\dots<\ell_r$, are all
the corners of a graded ideal I of $S$, the set
$\mathrm{Corn}(I)=\Big\{(k_1,\ell_1),(k_2,\ell_2),\dots,(k_r,\ell_r)\Big\}$ is
called the corner sequence of I.
We recall that I has a minimal graded free $S$ resolution:$
F_{\scriptscriptstyle\bullet}:0\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{r,j}}\rightarrow \cdots\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{1,j}}\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{0,j}}\rightarrow I\rightarrow 0.$
The integer $\beta_{i,j}$ is a graded Betti number of I and it represents the
dimension as a $K$-vector space of the $j$-th graded component of the $i$-th
free module of the resolution. Each of the numbers
$\beta_i=\sum_{j\in\mathbb{Z}}\beta_{i,j}$ is called the $i$-th Betti number of
I.

Example:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_10]                                                         |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I=ideal(x_1*x_3,x_1*x_4,x_1*x_5,x_2*x_4*x_6,x_2*x_4*x_7,x_2*x_5*x_7*x_9,|
|                                                                             |
|o2 = ideal (x x , x x , x x , x x x , x x x , x x x x , x x x x )            |
|             1 3   1 4   1 5   2 4 6   2 4 7   2 5 7 9   3 5 7 9             |
|                                                                             |
|o2 : Ideal of S                                                              |
|-----------------------------------------------------------------------------|
|x_3*x_5*x_7*x_9)                                                             |
+-----------------------------------------------------------------------------+
|i3 : tExtremalBettiCorners(I,2)                                              |
|                                                                             |
|o3 = {(2, 4)}                                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : minimalBettiNumbersIdeal I                                              |
|                                                                             |
|            0  1 2                                                           |
|o4 = total: 7 10 4                                                           |
|         2: 3  3 1                                                           |
|         3: 2  3 1                                                           |
|         4: 2  4 2                                                           |
|                                                                             |
|o4 : BettiTally                                                              |
+-----------------------------------------------------------------------------+

Ways to use tExtremalBettiCorners:
==================================

  * "tExtremalBettiCorners(Ideal,ZZ)"

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

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

tExtremalBettiMonomials -- give the list of the t-spread basic monomials related to the given extremal Betti numbers configuration
**********************************************************************************************************************************

Synopsis
========

  * Usage:
        tExtremalBettiMonomials(S,corners,a,t)
  * Inputs:
      * S, a polynomial ring
      * corners, a list of pairs of positive integers
      * a, a list of positive integers
      * t, a positive integer that identifies the t-spread contest
  * Outputs:
      * a list (Macaulay2Doc), the t-spread basic monomials to
        obtain the extremal Betti numbers positioned in cornes and with values
        a

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

let $S=K[x_1,\ldots,x_n]$ be a polynomial ring over a field $K$ and let I a
graded ideal of $S$. A graded Betti number of the ideal $\beta_{k,k+\ell}(I)\ne
0$ is called extremal if $\beta_{i,i+j}(I)=0$ for all $i\ge
k,j\ge\ell,(i,j)\ne(k,\ell).$
The basic monomials related to an extremal Betti number configuration (values
as well as positions) are defined by the following characterization. Let $I$ be
a $t$-spread strongly stable ideal of S and let $\beta_{k,k+\ell}(I)$ be an
extremal Betti number of $I$. Then $\beta_{k,k+\ell}(I)=\Big|\Big\{ u\in
G(I)_\ell:\max(u)=k+t(\ell-1)+1 \Big\}\Big|.$
Let $\beta_{k,k+\ell}(I)$ be an extremal Betti number of I, the pair $(k,\ell)$
is called a corner of I. If $(k_1,\ell_1),\dots,(k_r,\ell_r)$, with $n-1\ge
k_1>k_2>\dots>k_r\ge1 \text{ and } 1\le \ell_1<\ell_2<\dots<\ell_r$, are all
the corners of a graded ideal I of $S$, the set
$\mathrm{Corn}(I)=\Big\{(k_1,\ell_1),(k_2,\ell_2),\dots,(k_r,\ell_r)\Big\}$ is
called the corner sequence of I.
We recall that I has a minimal graded free $S$ resolution:$
F_{\scriptscriptstyle\bullet}:0\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{r,j}}\rightarrow \cdots\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{1,j}}\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{0,j}}\rightarrow I\rightarrow 0.$
The integer $\beta_{i,j}$ is a graded Betti number of I and it represents the
dimension as a $K$-vector space of the $j$-th graded component of the $i$-th
free module of the resolution. Each of the numbers
$\beta_i=\sum_{j\in\mathbb{Z}}\beta_{i,j}$ is called the $i$-th Betti number of
I.

Example:

+-----------------------------------------------------------------------------+
|i1 : S=QQ[x_1..x_12]                                                         |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : corners={{4,2},{3,4},{2,5}}                                             |
|                                                                             |
|o2 = {{4, 2}, {3, 4}, {2, 5}}                                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : a={1,2,1}                                                               |
|                                                                             |
|o3 = {1, 2, 1}                                                               |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : l=tExtremalBettiMonomials(S,corners,a,2)                                |
|                                                                             |
|o4 = {x x , x x x x  , x x x x  , x x x x x  }                               |
|       1 7   2 4 6 10   2 4 7 10   2 5 7 9 11                                |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : I=tStronglyStableIdeal(ideal l,2)                                       |
|                                                                             |
|o5 = ideal (x x , x x , x x , x x , x x , x x x x , x x x x , x x x x  ,     |
|             1 3   1 4   1 5   1 6   1 7   2 4 6 8   2 4 6 9   2 4 6 10      |
|     ------------------------------------------------------------------------|
|     x x x x , x x x x  , x x x x x  )                                       |
|      2 4 7 9   2 4 7 10   2 5 7 9 11                                        |
|                                                                             |
|o5 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i6 : minimalBettiNumbersIdeal I                                              |
|                                                                             |
|             0  1  2 3 4                                                     |
|o6 = total: 11 23 19 7 1                                                     |
|         2:  5 10 10 5 1                                                     |
|         3:  .  .  . . .                                                     |
|         4:  5 11  8 2 .                                                     |
|         5:  1  2  1 . .                                                     |
|                                                                             |
|o6 : BettiTally                                                              |
+-----------------------------------------------------------------------------+

Ways to use tExtremalBettiMonomials:
====================================

  * "tExtremalBettiMonomials(Ring,List,List,ZZ)"

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

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

solveBinomialExpansion -- compute the sum of a binomial expansion
*****************************************************************

Synopsis
========

  * Usage:
        solveBinomialExpansion l
  * Inputs:
      * l, a list of pairs of integers representing a binomial expansion
  * Outputs:
      * an integer (Macaulay2Doc), the sum of binomials in the listl

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

Given a list of pairs $\{\{a_1,b_1\}, ... ,\{a_k,b_k\}\}$ this method yields
the sum of binomials $\binom{a_1,b_1} + \cdots + \binom{a_k,b_k}.$

Example:

+---------------------------------------------------------+
|i1 : solveBinomialExpansion({{4,2},{3,1}})               |
|                                                         |
|o1 = 9                                                   |
+---------------------------------------------------------+
|i2 : solveBinomialExpansion tMacaulayExpansion(50,12,2,1)|
|                                                         |
|o2 = 50                                                  |
+---------------------------------------------------------+

See also
========

  * tMacaulayExpansion -- compute the t-Macaulay
    expansion of a positive integer

Ways to use solveBinomialExpansion:
===================================

  * "solveBinomialExpansion(List)"

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

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

initialDegree -- return the initial degree of a given graded ideal
******************************************************************

Synopsis
========

  * Usage:
        initialDegree I
  * Inputs:
      * I, a graded ideal of a polynomial ring
  * Outputs:
      * an integer (Macaulay2Doc), the initial degree of the ideal I

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

The initial degree of a graded ideal I is the least degree of a homogeneous
generator of I.

Example:

+----------------------------------------------+
|i1 : S=QQ[x_1..x_4]                           |
|                                              |
|o1 = S                                        |
|                                              |
|o1 : PolynomialRing                           |
+----------------------------------------------+
|i2 : initialDegree ideal {x_1*x_2,x_2*x_3*x_4}|
|                                              |
|o2 = 2                                        |
+----------------------------------------------+
|i3 : initialDegree ideal {x_1*x_3*x_4}        |
|                                              |
|o3 = 3                                        |
+----------------------------------------------+

Ways to use initialDegree:
==========================

  * "initialDegree(Ideal)"

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

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

initialIdeal -- return the initial ideal of a given ideal
*********************************************************

Synopsis
========

  * Usage:
        initialIdeal I
  * Inputs:
      * I, a graded ideal of a polynomial ring
  * Outputs:
      * an ideal (Macaulay2Doc), the initial ideal of the ideal I
        with default monomial order

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

let $S=K[x_1,\ldots,x_n]$ be a polynomial ring over a field $K$. Let > be a
monomial order on $S$. The largest monomial of a polynomial $f\in S$ is called
the initial monomial of $f$ and it is denoted by $\mathrm{In}(f).$
If I is a graded ideal of $S$ then the initial ideal of I, denoted by
$\mathrm{In}(I)$, is the ideal of $S$ generated by the initial terms of
elements of I.

Example:

+--------------------------------------------------------------+
|i1 : S=QQ[x_1..x_5]                                           |
|                                                              |
|o1 = S                                                        |
|                                                              |
|o1 : PolynomialRing                                           |
+--------------------------------------------------------------+
|i2 : I=ideal {x_1*x_2+x_3*x_4*x_5,x_1*x_3+x_4*x_5,x_2*x_3*x_4}|
|                                                              |
|o2 = ideal (x x x  + x x , x x  + x x , x x x )               |
|             3 4 5    1 2   1 3    4 5   2 3 4                |
|                                                              |
|o2 : Ideal of S                                               |
+--------------------------------------------------------------+
|i3 : initialIdeal I                                           |
|                                                              |
|             2         2     2 2     2                        |
|o3 = ideal (x x x , x x x , x x , x x , x x x , x x x , x x ) |
|             2 4 5   2 4 5   4 5   1 2   2 3 4   3 4 5   1 3  |
|                                                              |
|o3 : Ideal of S                                               |
+--------------------------------------------------------------+

Ways to use initialIdeal:
=========================

  * "initialIdeal(Ideal)"

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

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

minimalBettiNumbers -- return the minimal Betti numbers of the quotient ring corresponding to a given graded ideal
******************************************************************************************************************

Synopsis
========

  * Usage:
        minimalBettiNumbers I
  * Inputs:
      * I, a graded ideal of a polynomial ring
  * Outputs:
      * a Betti tally (Macaulay2Doc), the Betti table of the
        quotient S/I computed using its minimal generators

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

Example:

+--------------------------------------------------------+
|i1 : S=QQ[x_1..x_4]                                     |
|                                                        |
|o1 = S                                                  |
|                                                        |
|o1 : PolynomialRing                                     |
+--------------------------------------------------------+
|i2 : I=ideal(x_1*x_2,x_1*x_3,x_2*x_3)                   |
|                                                        |
|o2 = ideal (x x , x x , x x )                           |
|             1 2   1 3   2 3                            |
|                                                        |
|o2 : Ideal of S                                         |
+--------------------------------------------------------+
|i3 : J=ideal(join(flatten entries gens I,{x_1*x_2*x_3}))|
|                                                        |
|o3 = ideal (x x , x x , x x , x x x )                   |
|             1 2   1 3   2 3   1 2 3                    |
|                                                        |
|o3 : Ideal of S                                         |
+--------------------------------------------------------+
|i4 : I==J                                               |
|                                                        |
|o4 = true                                               |
+--------------------------------------------------------+
|i5 : betti I==betti J                                   |
|                                                        |
|o5 = false                                              |
+--------------------------------------------------------+
|i6 : minimalBettiNumbers I==minimalBettiNumbers J       |
|                                                        |
|o6 = true                                               |
+--------------------------------------------------------+

Ways to use minimalBettiNumbers:
================================

  * "minimalBettiNumbers(Ideal)"

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

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

minimalBettiNumbersIdeal -- return the minimal Betti numbers of a given graded ideal
************************************************************************************

Synopsis
========

  * Usage:
        minimalBettiNumbersIdeal I
  * Inputs:
      * I, a graded ideal of a polynomial ring
  * Outputs:
      * a Betti tally (Macaulay2Doc), the Betti table of the
        ideal I computed using its minimal generators

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

let $S=K[x_1,\ldots,x_n]$ be a polynomial ring over a field $K$ and let I a
graded ideal of $S$. Then I has a minimal graded free $S$ resolution:$
F_{\scriptscriptstyle\bullet}:0\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{r,j}}\rightarrow \cdots\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{1,j}}\rightarrow
\bigoplus_{j\in\mathbb{Z}}S(-j)^{\beta_{0,j}}\rightarrow I\rightarrow 0.$
The integer $\beta_{i,j}$ is a graded Betti number of I and it represents the
dimension as a $K$-vector space of the $j$-th graded component of the $i$-th
free module of the resolution. Each of the numbers
$\beta_i=\sum_{j\in\mathbb{Z}}\beta_{i,j}$ is called the $i$-th Betti number of
I.

Example:

+-----------------------------------------------------------+
|i1 : S=QQ[x_1..x_4]                                        |
|                                                           |
|o1 = S                                                     |
|                                                           |
|o1 : PolynomialRing                                        |
+-----------------------------------------------------------+
|i2 : I=ideal(x_1*x_2,x_1*x_3,x_2*x_3)                      |
|                                                           |
|o2 = ideal (x x , x x , x x )                              |
|             1 2   1 3   2 3                               |
|                                                           |
|o2 : Ideal of S                                            |
+-----------------------------------------------------------+
|i3 : J=ideal(join(flatten entries gens I,{x_1*x_2*x_3}))   |
|                                                           |
|o3 = ideal (x x , x x , x x , x x x )                      |
|             1 2   1 3   2 3   1 2 3                       |
|                                                           |
|o3 : Ideal of S                                            |
+-----------------------------------------------------------+
|i4 : I==J                                                  |
|                                                           |
|o4 = true                                                  |
+-----------------------------------------------------------+
|i5 : betti I==betti J                                      |
|                                                           |
|o5 = false                                                 |
+-----------------------------------------------------------+
|i6 : minimalBettiNumbersIdeal I==minimalBettiNumbersIdeal J|
|                                                           |
|o6 = true                                                  |
+-----------------------------------------------------------+

Ways to use minimalBettiNumbersIdeal:
=====================================

  * "minimalBettiNumbersIdeal(Ideal)"

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

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

Shift -- optional boolean argument for tMacaulayExpansion
*********************************************************

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

whether it is true the function tMacaulayExpansion gives the $i$-th shifted
Macaulay expansion of $a$. Given four positive integers $(a,n,d,t)$ the $d$-th
shifted t-Macaulay expansion is a sum of binomials: $\binom{a_d}{d+1} +
\binom{a_{d-1}}{d} + \cdots + \binom{a_j}{j+1}.$

See also
========

  * tMacaulayExpansion -- compute the t-Macaulay
    expansion of a positive integer

Functions with optional argument named Shift:
=============================================

  * "tMacaulayExpansion(...,Shift=>...)"

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

The object Shift, is a symbol (Macaulay2Doc).

FixedMax -- optional boolean argument for tNextMon
**************************************************

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

whether it is true the function tNextMon(u,t,FixedMax=>true) gives the t-lex
successor for which the maximum of the support is
$\max\textrm{supp}(\texttt{u})$. Given a $t$-spread monomial
$u=x_{i_1}x_{i_2}\cdots x_{i_d}$, we define $\textrm{supp}(u)=\{i_1,i_2,\ldots,
i_d\}$.

See also
========

  * tNextMon -- give the t-lex successor of a given t-spread
    monomial
  * countTLexMon -- give the cardinality of the smallest
    initial t-lex segment containing a given monomial

Functions with optional argument named FixedMax:
================================================

  * "countTLexMon(...,FixedMax=>...)"
  * "tNextMon(...,FixedMax=>...)"

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

The object FixedMax, is a symbol (Macaulay2Doc).

MaxInd -- optional integer argument for tLastMon
************************************************

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

whether it is greater than -1 the function tLastMon(u,t,MaxInd=>m) gives the
smallest t-spread monomial for which the maximum of the support is
$\max\textrm{supp}(\texttt{u})$ of the Borel shadow of
$B_\texttt{t}\{\texttt{u}\}$. Given a $t$-spread monomial
$u=x_{i_1}x_{i_2}\cdots x_{i_d}$, we define $\textrm{supp}(u)=\{i_1,i_2,\ldots,
i_d\}$.

See also
========

  * tLastMon -- give the last t-spread monomial of the Borel
    shadow a given t-spread monomial
  * tShadow -- give the t-spread shadow of a given t-spread
    monomial or a given list of t-spread monomials

Functions with optional argument named MaxInd:
==============================================

  * "tLastMon(...,MaxInd=>...)"

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

The object MaxInd, is a symbol (Macaulay2Doc).