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

ExteriorIdeals -- a package for working with ideals over exterior algebra
*************************************************************************

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

ExteriorIdeals is a package for creating and manipulating ideals over exterior
algebra

Acknowledgement
===============

The method isLexIdeal, was taken from isLexIdeal (LexIdeals),
in Chris Francisco's package LexIdeals.

Authors
=======

  * Marilena Crupi (see http://www.unime.it/it/persona/marilena-crupi )
    <mcrupi@unime.it>
  * Luca Amata (see http://mat521.unime.it/amata ) <lamata@unime.it>

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

Version 1.0 of this package was accepted for publication in volume 8 (see
https://msp.org/jsag/2018/8-1/ ) of The Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 24 June 2018, in the article
ExteriorIdeals: a package for computing monomial ideals in an exterior algebra
(see https://msp.org/jsag/2018/8-1/p07.xhtml ) (DOI: 10.2140/jsag.2018.8.71
(see https://doi.org/10.2140/jsag.2018.8.71 )). That version can be obtained
from the journal (see https://msp.org/jsag/2018/8-1/jsag-v8-n1-x07-
ExteriorIdeals.m2 ).

Version
=======

This documentation describes version 1.1 of ExteriorIdeals, released February
13, 2018.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{ExteriorIdealsSource,                                                  |
|  title = {{ExteriorIdeals: monomial ideals over exterior algebras. Version~1|
|  author = {Marilena Crupi and Luca Amata},                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{ExteriorIdealsArticle,                                              |
|  title = {{ExteriorIdeals: a package for computing monomial ideals in an ext|
|  author = {Marilena Crupi and Luca Amata},                                  |
|  journal = {The Journal of Software for Algebra and Geometry},              |
|  volume = {8},                                                              |
|  year = {2018},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|.1}},                                                                        |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|erior algebra}},                                                             |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * allHilbertSequences -- compute all Hilbert
        sequences of quotients in an exterior algebra
      * hilbertSequence -- compute the Hilbert sequence
        of a given ideal in an exterior algebra
      * initialDegree -- compute the initial degree of a
        graded ideal
      * initialIdeal -- compute the initial ideal of a
        given ideal
      * isHilbertSequence -- whether the given
        sequence is a Hilbert sequence
      * isLexIdeal -- whether an ideal is lex
      * isStableIdeal -- whether a monomial ideal in an
        exterior algebra is stable
      * isStronglyStableIdeal -- whether a
        monomial ideal in an exterior algebra is strongly stable
      * lexIdeal -- compute the lex ideal with a given Hilbert
        function in an exterior algebra
      * macaulayExpansion -- compute the Macaulay
        expansion of a positive integer
      * minimalBettiNumbers -- compute the minimal
        Betti numbers of a given graded ideal
      * solveMacaulayExpansion -- compute the
        sum of a Macaulay expansion
      * stableIdeal -- compute the smallest stable ideal in
        an exterior algebra containing a given monomial ideal
      * stronglyStableIdeal -- compute the smallest
        strongly stable ideal in an exterior algebra containing a given
        monomial ideal
  * Methods
      * "allHilbertSequences(Ring)" -- see allHilbertSequences,
        -- compute all Hilbert sequences of quotients in
        an exterior algebra
      * "hilbertSequence(Ideal)" -- see hilbertSequence,
        -- compute the Hilbert sequence of a given ideal in an exterior algebra
      * "initialDegree(Ideal)" -- see initialDegree, --
        compute the initial degree of a graded ideal
      * "initialIdeal(Ideal)" -- see initialIdeal, --
        compute the initial ideal of a given ideal
      * "isHilbertSequence(List,Ring)" -- see isHilbertSequence,
        -- whether the given sequence is a Hilbert sequence
      * "isLexIdeal(Ideal)" -- see isLexIdeal, -- whether an
        ideal is lex
      * "isStableIdeal(Ideal)" -- see isStableIdeal, --
        whether a monomial ideal in an exterior algebra is stable
      * "isStronglyStableIdeal(Ideal)" -- see isStronglyStableIdeal,
        -- whether a monomial ideal in an exterior
        algebra is strongly stable
      * "lexIdeal(Ideal)" -- see lexIdeal, -- compute the lex
        ideal with a given Hilbert function in an exterior algebra
      * "lexIdeal(List,Ring)" -- see lexIdeal, -- compute the
        lex ideal with a given Hilbert function in an exterior algebra
      * "macaulayExpansion(ZZ,ZZ)" -- see macaulayExpansion,
        -- compute the Macaulay expansion of a positive
        integer
      * "minimalBettiNumbers(Ideal)" -- see minimalBettiNumbers,
        -- compute the minimal Betti numbers of a given
        graded ideal
      * "solveMacaulayExpansion(List)" -- see solveMacaulayExpansion,
        -- compute the sum of a Macaulay expansion
      * "stableIdeal(Ideal)" -- see stableIdeal, -- compute
        the smallest stable ideal in an exterior algebra containing a given
        monomial ideal
      * "stronglyStableIdeal(Ideal)" -- see stronglyStableIdeal,
        -- compute the smallest strongly stable ideal in
        an exterior algebra containing a given monomial ideal
  * Symbols
      * Shift -- optional argument for macaulayExpansion

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

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

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

The source of this document is in ExteriorIdeals.m2:396:0.

allHilbertSequences -- compute all Hilbert sequences of quotients in an exterior algebra
****************************************************************************************

  * Usage:
        allHilbertSequences E
  * Inputs:
      * E, an exterior algebra
  * Outputs:
      * a list (Macaulay2Doc), all Hilbert sequences of quotients
        of E

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

A sequence is called a Hilbert sequence whether it satisfies the Kruskal-Katona
theorem in the exterior algebra E.

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : allHilbertSequences E                                                   |
|                                                                             |
|o2 = {{1, 4, 6, 4, 1}, {1, 4, 6, 4, 0}, {1, 4, 6, 3, 0}, {1, 4, 6, 2, 0}, {1,|
|     ------------------------------------------------------------------------|
|     4, 6, 1, 0}, {1, 4, 6, 0, 0}, {1, 4, 5, 2, 0}, {1, 4, 5, 1, 0}, {1, 4,  |
|     ------------------------------------------------------------------------|
|     5, 0, 0}, {1, 4, 4, 1, 0}, {1, 4, 4, 0, 0}, {1, 4, 3, 1, 0}, {1, 4, 3,  |
|     ------------------------------------------------------------------------|
|     0, 0}, {1, 4, 2, 0, 0}, {1, 4, 1, 0, 0}, {1, 4, 0, 0, 0}, {1, 3, 3, 1,  |
|     ------------------------------------------------------------------------|
|     0}, {1, 3, 3, 0, 0}, {1, 3, 2, 0, 0}, {1, 3, 1, 0, 0}, {1, 3, 0, 0, 0}, |
|     ------------------------------------------------------------------------|
|     {1, 2, 1, 0, 0}, {1, 2, 0, 0, 0}, {1, 1, 0, 0, 0}, {1, 0, 0, 0, 0}, {0, |
|     ------------------------------------------------------------------------|
|     0, 0, 0, 0}, {-1, 0, 0, 0, 0}}                                          |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * lexIdeal -- compute the lex ideal with a given Hilbert
    function in an exterior algebra
  * isHilbertSequence -- whether the given sequence
    is a Hilbert sequence

Ways to use allHilbertSequences:
================================

  * "allHilbertSequences(Ring)"

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

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

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

The source of this document is in ExteriorIdeals.m2:533:0.

hilbertSequence -- compute the Hilbert sequence of a given ideal in an exterior algebra
***************************************************************************************

  * Usage:
        hilbertSequence I
  * Inputs:
      * I, an ideal of an exterior algebra E
  * Outputs:
      * a list (Macaulay2Doc), nonnegative integers representing
        the Hilbert sequence of the quotient E/I

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

Given sum{h_i t^i}, i=1..n the Hilbert series of a graded K-algebra E/I, the
sequence (1, h_1, ...,  h_n) is called the Hilbert sequence of  E/I.

Example:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : hilbertSequence ideal {e_1*e_2,e_2*e_3*e_4}   |
|                                                   |
|o2 = {1, 4, 5, 1, 0}                               |
|                                                   |
|o2 : List                                          |
+---------------------------------------------------+
|i3 : hilbertSequence ideal {e_2*e_3*e_4}           |
|                                                   |
|o3 = {1, 4, 6, 3, 0}                               |
|                                                   |
|o3 : List                                          |
+---------------------------------------------------+

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

  * "hilbertSequence(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:462:0.

initialDegree -- compute the initial degree of a graded ideal
*************************************************************

  * Usage:
        initialDegree I
  * Inputs:
      * I, a graded ideal
  * Outputs:
      * an integer (Macaulay2Doc), representing 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 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : initialDegree ideal {e_1*e_2,e_2*e_3*e_4}     |
|                                                   |
|o2 = 2                                             |
+---------------------------------------------------+
|i3 : initialDegree ideal {e_1*e_3*e_4}             |
|                                                   |
|o3 = 3                                             |
+---------------------------------------------------+

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

  * "initialDegree(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:446:0.

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

  * Usage:
        initialIdeal I
  * Inputs:
      * I, an ideal of an exterior algebra
  * Outputs:
      * an ideal (Macaulay2Doc), the initial ideal of the ideal I
        with default monomial order

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

Example:

+--------------------------------------------------------------+
|i1 : E=QQ[e_1..e_5,SkewCommutative=>true]                     |
|                                                              |
|o1 = E                                                        |
|                                                              |
|o1 : PolynomialRing, 5 skew commutative variable(s)           |
+--------------------------------------------------------------+
|i2 : I=ideal {e_1*e_2+e_3*e_4*e_5,e_1*e_3+e_4*e_5,e_2*e_3*e_4}|
|                                                              |
|o2 = ideal (e e e  + e e , e e  + e e , e e e )               |
|             3 4 5    1 2   1 3    4 5   2 3 4                |
|                                                              |
|o2 : Ideal of E                                               |
+--------------------------------------------------------------+
|i3 : initialIdeal I                                           |
|                                                              |
|o3 = ideal (e e e , e e e , e e e , e e e , e e , e e )       |
|             2 3 4   1 4 5   2 4 5   3 4 5   1 2   1 3        |
|                                                              |
|o3 : Ideal of E                                               |
+--------------------------------------------------------------+

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

  * "initialIdeal(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:630:0.

isHilbertSequence -- whether the given sequence is a Hilbert sequence
*********************************************************************

  * Usage:
        isHilbertSequence(l,E)
  * Inputs:
      * l, a list of integers
      * E, an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), true whether the
        sequence l satisfies the Kruskal-Katona theorem in the exterior algebra
        E

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

Example:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : isHilbertSequence({1,4,3,1,0},E)              |
|                                                   |
|o2 = true                                          |
+---------------------------------------------------+
|i3 : isHilbertSequence({1,4,3,1,1},E)              |
|                                                   |
|o3 = false                                         |
+---------------------------------------------------+

See also
========

  * lexIdeal -- compute the lex ideal with a given Hilbert
    function in an exterior algebra

Ways to use isHilbertSequence:
==============================

  * "isHilbertSequence(List,Ring)"

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

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

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

The source of this document is in ExteriorIdeals.m2:498:0.

isLexIdeal -- whether an ideal is lex
*************************************

  * Usage:
        isLexIdeal I
  * Inputs:
      * I, a monomial ideal of an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), true whether ideal I is
        lex

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

Examples:

+-------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]              |
|                                                       |
|o1 = E                                                 |
|                                                       |
|o1 : PolynomialRing, 4 skew commutative variable(s)    |
+-------------------------------------------------------+
|i2 : isLexIdeal ideal {e_1*e_2,e_2*e_3}                |
|                                                       |
|o2 = false                                             |
+-------------------------------------------------------+
|i3 : isLexIdeal ideal {e_1*e_2,e_1*e_3,e_1*e_4,e_2*e_3}|
|                                                       |
|o3 = true                                              |
+-------------------------------------------------------+

Acknowledgement
===============

This method was taken from isLexIdeal (LexIdeals), in Chris
Francisco's package LexIdeals.

See also
========

  * lexIdeal -- compute the lex ideal with a given Hilbert
    function in an exterior algebra

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

  * "isLexIdeal(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:481:0.

isStableIdeal -- whether a monomial ideal in an exterior algebra is stable
**************************************************************************

  * Usage:
        isStableIdeal I
  * Inputs:
      * I, a monomial ideal of an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), true whether ideal I is
        stable

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

Examples:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : isStableIdeal ideal {e_2*e_3}                 |
|                                                   |
|o2 = false                                         |
+---------------------------------------------------+
|i3 : isStableIdeal ideal {e_1*e_2,e_2*e_3}         |
|                                                   |
|o3 = true                                          |
+---------------------------------------------------+

See also
========

  * stableIdeal -- compute the smallest stable ideal in an
    exterior algebra containing a given monomial ideal

Ways to use isStableIdeal:
==========================

  * "isStableIdeal(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:580:0.

isStronglyStableIdeal -- whether a monomial ideal in an exterior algebra is strongly stable
*******************************************************************************************

  * Usage:
        isStronglyStableIdeal I
  * Inputs:
      * I, a monomial ideal of an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), true whether ideal I is
        strongly stable

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

Examples:

+----------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                 |
|                                                          |
|o1 = E                                                    |
|                                                          |
|o1 : PolynomialRing, 4 skew commutative variable(s)       |
+----------------------------------------------------------+
|i2 : isStronglyStableIdeal ideal {e_2*e_3}                |
|                                                          |
|o2 = false                                                |
+----------------------------------------------------------+
|i3 : isStronglyStableIdeal ideal {e_1*e_2,e_1*e_3,e_2*e_3}|
|                                                          |
|o3 = true                                                 |
+----------------------------------------------------------+

See also
========

  * stronglyStableIdeal -- compute the smallest
    strongly stable ideal in an exterior algebra containing a given monomial
    ideal

Ways to use isStronglyStableIdeal:
==================================

  * "isStronglyStableIdeal(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:549:0.

lexIdeal -- compute the lex ideal with a given Hilbert function in an exterior algebra
**************************************************************************************

  * Usage:
        lexIdeal(hs,E) or lexIdeal I
  * Inputs:
      * hs, a list of integers
      * E, an exterior algebra
      * I, an ideal of an exterior algebra
  * Outputs:
      * an ideal (Macaulay2Doc), the lex ideal with Hilbert
        sequence hs or the lex ideal with the same Hilbert sequence of I

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

Examples:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : lexIdeal({1,4,3,1,0},E)                       |
|                                                   |
|o2 = ideal (e e , e e , e e )                      |
|             1 2   1 3   1 4                       |
|                                                   |
|o2 : Ideal of E                                    |
+---------------------------------------------------+
|i3 : Ilex=lexIdeal ideal {e_1*e_2,e_2*e_3}         |
|                                                   |
|o3 = ideal (e e , e e )                            |
|             1 2   1 3                             |
|                                                   |
|o3 : Ideal of E                                    |
+---------------------------------------------------+
|i4 : isLexIdeal Ilex                               |
|                                                   |
|o4 = true                                          |
+---------------------------------------------------+

See also
========

  * isLexIdeal -- whether an ideal is lex
  * isHilbertSequence -- whether the given sequence
    is a Hilbert sequence

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

  * "lexIdeal(Ideal)"
  * "lexIdeal(List,Ring)"

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

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

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

The source of this document is in ExteriorIdeals.m2:517:0.

macaulayExpansion -- compute the Macaulay expansion of a positive integer
*************************************************************************

  * Usage:
        macaulayExpansion(a,i)
  * Inputs:
      * a, a positive integer
      * i, a positive integer
  * Optional inputs (Macaulay2Doc),:
      * Shift, => ..., default value false, optional argument for
        macaulayExpansion
  * Outputs:
      * a list (Macaulay2Doc), pairs of positive integers
        representing the i-th (shifted) Macaulay expansion of a

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

Given a pair of positive integers (a,i) there is a unique expression of a as a
sum of binomials  a=binomial(a_i,i) + binomial(a_{i-1},i-1) + ... +
binomial(a_j,j) where  a_i > a_{i-1} > ... > a_j > j >= 1.

Examples:

+----------------------------------------+
|i1 : macaulayExpansion(8,4)             |
|                                        |
|o1 = {{5, 4}, {3, 3}, {2, 2}, {1, 1}}   |
|                                        |
|o1 : List                               |
+----------------------------------------+
|i2 : macaulayExpansion(3,1,Shift=>false)|
|                                        |
|o2 = {{3, 1}}                           |
|                                        |
|o2 : List                               |
+----------------------------------------+
|i3 : macaulayExpansion(8,4,Shift=>true) |
|                                        |
|o3 = {{5, 5}, {3, 4}, {2, 3}, {1, 2}}   |
|                                        |
|o3 : List                               |
+----------------------------------------+
|i4 : macaulayExpansion(3,1,Shift=>true) |
|                                        |
|o4 = {{3, 2}}                           |
|                                        |
|o4 : List                               |
+----------------------------------------+

See also
========

  * solveMacaulayExpansion -- compute the sum of
    a Macaulay expansion

Ways to use macaulayExpansion:
==============================

  * "macaulayExpansion(ZZ,ZZ)"

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

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

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

The source of this document is in ExteriorIdeals.m2:415:0.

minimalBettiNumbers -- compute the minimal Betti numbers of a given graded ideal
********************************************************************************

  * Usage:
        minimalBettiNumbers(I, LengthLimit => lim)
  * Inputs:
      * I, a graded ideal of an exterior algebra
  * Optional inputs (Macaulay2Doc),:
      * LengthLimit => an integer (Macaulay2Doc), default value
        infinity, only compute enough to determine the Betti table up to and
        including the column labelled lim
  * Outputs:
      * a Betti tally (Macaulay2Doc), the Betti table of the
        ideal I computed using its minimal generators

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

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : I=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                                        |
|                                                                             |
|o2 = ideal (e e , e e , e e )                                                |
|             1 2   1 3   2 3                                                 |
|                                                                             |
|o2 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i3 : J=ideal(join(flatten entries gens I,{e_1*e_2*e_3}))                     |
|                                                                             |
|o3 = ideal (e e , e e , e e , e e e )                                        |
|             1 2   1 3   2 3   1 2 3                                         |
|                                                                             |
|o3 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i4 : I==J                                                                    |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+
|i5 : betti I==betti J                                                        |
|                                                                             |
|o5 = false                                                                   |
+-----------------------------------------------------------------------------+
|i6 : minimalBettiNumbers(I, LengthLimit => 5) == minimalBettiNumbers(J,      |
|                                                                             |
|o6 = true                                                                    |
|-----------------------------------------------------------------------------|
|LengthLimit => 5)                                                            |
+-----------------------------------------------------------------------------+

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

  * "minimalBettiNumbers(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:615:0.

Shift -- optional argument for macaulayExpansion
************************************************

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

Whether it is true the function macaulayExpansion gives the i-th shifted
Macaulay expansion of a. Given a pair of positive integers (a,i) the i-th
shifted Macaulay expansion is a sum of binomials:  binomial(a_i,i+1) +
binomial(a_{i-1},i) + ... + binomial(a_j,j+1).

See also
========

  * macaulayExpansion -- compute the Macaulay
    expansion of a positive integer

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

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

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

The object Shift, is a symbol (Macaulay2Doc).

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

The source of this document is in ExteriorIdeals.m2:647:0.

solveMacaulayExpansion -- compute the sum of a Macaulay expansion
*****************************************************************

  * Usage:
        solveMacaulayExpansion l
  * Inputs:
      * l, a list of pairs of natural numbers representing a Macaulay expansion
  * Outputs:
      * an integer (Macaulay2Doc), representing 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  binomial(a_1,b_1) + ... + binomial(a_k,b_k).

Example:

+------------------------------------------+
|i1 : solveMacaulayExpansion({{4,2},{3,1}})|
|                                          |
|o1 = 9                                    |
+------------------------------------------+

See also
========

  * macaulayExpansion -- compute the Macaulay
    expansion of a positive integer

Ways to use solveMacaulayExpansion:
===================================

  * "solveMacaulayExpansion(List)"

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

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

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

The source of this document is in ExteriorIdeals.m2:430:0.

stableIdeal -- compute the smallest stable ideal in an exterior algebra containing a given monomial ideal
*********************************************************************************************************

  * Usage:
        stableIdeal I
  * Inputs:
      * I, a monomial ideal of an exterior algebra
  * Outputs:
      * an ideal (Macaulay2Doc), the smallest stable ideal
        containing ideal I

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

Example:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : stableIdeal ideal {e_2*e_3}                   |
|                                                   |
|o2 = ideal (e e , e e )                            |
|             1 2   2 3                             |
|                                                   |
|o2 : Ideal of E                                    |
+---------------------------------------------------+

See also
========

  * isStableIdeal -- whether a monomial ideal in an
    exterior algebra is stable

Ways to use stableIdeal:
========================

  * "stableIdeal(Ideal)"

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

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

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

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

stronglyStableIdeal -- compute the smallest strongly stable ideal in an exterior algebra containing a given monomial ideal
**************************************************************************************************************************

  * Usage:
        stronglyStableIdeal I
  * Inputs:
      * I, a monomial ideal of an exterior algebra
  * Outputs:
      * an ideal (Macaulay2Doc), the smallest strongly stable
        ideal containing I

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

Example:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : stronglyStableIdeal ideal {e_2*e_3}           |
|                                                   |
|o2 = ideal (e e , e e , e e )                      |
|             1 2   1 3   2 3                       |
|                                                   |
|o2 : Ideal of E                                    |
+---------------------------------------------------+

See also
========

  * isStronglyStableIdeal -- whether a monomial
    ideal in an exterior algebra is strongly stable

Ways to use stronglyStableIdeal:
================================

  * "stronglyStableIdeal(Ideal)"

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

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

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

The source of this document is in ExteriorIdeals.m2:564:0.