This is ExteriorModules.info, produced by Macaulay2, version 1.25.11

ExteriorModules -- a package for working with modules over exterior algebra
***************************************************************************

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

ExteriorModules is a package for creating and manipulating modules over
exterior algebra

Let $K$ be a field, $E$ the exterior algebra of a finite dimensional,
$K$-vector space, and $F$ a finitely generated graded free $E$-module with
homogeneous basis $g_1, \ldots, g_r$ such that $\mathrm{deg}(g_1) \le
\mathrm{deg}(g_2) \le \cdots \le \mathrm{deg}(g_r)$. We present a Macaulay2
package to manage some classes of monomial submodules of $F$. The package is an
extension of the one on monomial ideals, and contains some algorithms for
computing stable, strongly stable and lexicograhic $E$-submodules of $F$. Such
a package also includes some methods to check whether a sequence of nonnegative
integers is the Hilbert function of a graded $E$-module of the form $F/M$, with
$M$ graded submodule of $F$. Moreover, if $H_{F/M}$ is the Hilbert function of
a graded $E$-module $F/M$, some routines are able to compute the unique
lexicograhic submodule $L$ of $F$ such that $H_{F/M} = H_{F/L}.$

Authors
=======

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

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

Version 1.0 of this package was accepted for publication in volume 11 (see
https://msp.org/jsag/2021/11-1/ ) of The Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 3 June 2021, in the article
ExteriorModules: a package for computing monomial modules over an exterior
algebra (see https://msp.org/jsag/2021/11-1/p08.xhtml ) (DOI:
10.2140/jsag.2021.11.71 (see https://doi.org/10.2140/jsag.2021.11.71 )). That
version can be obtained from the journal (see
https://msp.org/jsag/2021/11-1/jsag-v11-n1-x08-ExteriorModules.zip ).

Version
=======

This documentation describes version 1.0 of ExteriorModules, released May 05,
2020.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{ExteriorModulesSource,                                                 |
|  title = {{ExteriorModules: monomial modules over exterior algebras. Version|
|  author = {Luca Amata and Marilena Crupi},                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{ExteriorModulesArticle,                                             |
|  title = {{ExteriorModules: a package for computing monomial modules over an|
|  author = {Luca Amata and Marilena Crupi},                                  |
|  journal = {The Journal of Software for Algebra and Geometry},              |
|  volume = {11},                                                             |
|  year = {2021},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|~1.0}},                                                                      |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
| exterior algebra}},                                                         |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * almostLexModule -- compute an almost lex module
        with the same Hilbert sequence of the module in input
      * almostStableModule -- compute the smallest
        almost stable module containing a given monomial module
      * almostStronglyStableModule, --
        compute the smallest almost strongly stable module containing a given
        monomial module
      * bassNumbers -- compute the Bass numbers of a given
        graded module
      * createModule -- create a module over an exterior
        algebra from a list of ideals in input
      * getIdeals -- get component ideals from a monomial
        module
      * initialModule -- compute the initial module of a
        given module
      * isAlmostLexModule -- whether a monomial
        module over an exterior algebra is almost lex
      * isAlmostStableModule -- whether a monomial
        module over an exterior algebra is almost stable
      * isAlmostStronglyStableModule, --
        whether a monomial module over an exterior algebra is almost strongly
        stable
      * isLexModule -- whether a monomial module over an
        exterior algebra is lex
      * isMonomialModule -- whether a module is
        monomial
      * isStableModule -- whether a monomial module over
        an exterior algebra is stable
      * isStronglyStableModule -- whether a
        monomial module over an exterior algebra is strongly stable
      * lexModule -- compute the lex submodule with a given
        Hilbert sequence in a free module
      * lexModuleBySequences -- alternative
        algorithm to compute the lex submodule with a given Hilbert sequence in
        a free module
      * stableModule -- compute the smallest stable module
        containing a given monomial module
      * stronglyStableModule -- compute the
        smallest strongly stable module containing a given monomial module
  * Methods
      * "almostLexModule(Module)" -- see almostLexModule,
        -- compute an almost lex module with the same Hilbert
        sequence of the module in input
      * "almostStableModule(Module)" -- see almostStableModule,
        -- compute the smallest almost stable module
        containing a given monomial module
      * "almostStronglyStableModule(Module)" -- see
        almostStronglyStableModule, -- compute the
        smallest almost strongly stable module containing a given monomial
        module
      * "bassNumbers(Module)" -- see bassNumbers, -- compute
        the Bass numbers of a given graded module
      * "createModule(List,Module)" -- see createModule, --
        create a module over an exterior algebra from a list of ideals in input
      * "getIdeals(Module)" -- see getIdeals, -- get component
        ideals from a monomial module
      * hilbertSequence(Module) -- compute
        the Hilbert sequence of a given module over an exterior algebra
      * "initialModule(Module)" -- see initialModule, --
        compute the initial module of a given module
      * "isAlmostLexModule(Module)" -- see isAlmostLexModule,
        -- whether a monomial module over an exterior
        algebra is almost lex
      * "isAlmostStableModule(Module)" -- see isAlmostStableModule,
        -- whether a monomial module over an exterior
        algebra is almost stable
      * "isAlmostStronglyStableModule(Module)" -- see
        isAlmostStronglyStableModule, -- whether
        a monomial module over an exterior algebra is almost strongly stable
      * isHilbertSequence(List,Module)
        -- whether the given sequence is
        a Hilbert sequence
      * "isLexModule(Module)" -- see isLexModule, -- whether
        a monomial module over an exterior algebra is lex
      * "isMonomialModule(Module)" -- see isMonomialModule,
        -- whether a module is monomial
      * "isStableModule(Module)" -- see isStableModule,
        -- whether a monomial module over an exterior algebra is stable
      * "isStronglyStableModule(Module)" -- see isStronglyStableModule,
        -- whether a monomial module over an exterior
        algebra is strongly stable
      * "lexModule(List,Module)" -- see lexModule, -- compute
        the lex submodule with a given Hilbert sequence in a free module
      * "lexModule(Module)" -- see lexModule, -- compute the
        lex submodule with a given Hilbert sequence in a free module
      * "lexModuleBySequences(List,Module)" -- see lexModuleBySequences,
        -- alternative algorithm to compute the lex
        submodule with a given Hilbert sequence in a free module
      * minimalBettiNumbers(Module), --
        compute the minimal Betti numbers of a given graded module
      * "stableModule(Module)" -- see stableModule, --
        compute the smallest stable module containing a given monomial module
      * "stronglyStableModule(Module)" -- see stronglyStableModule,
        -- compute the smallest strongly stable module
        containing a given monomial module

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

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

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

The source of this document is in ExteriorModules.m2:513:0.

almostLexModule -- compute an almost lex module with the same Hilbert sequence of the module in input
*****************************************************************************************************

  * Usage:
        almostLexModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), an almost lex submodule of the
        ambient module with the same Hilbert sequence of M

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F and let
$M=\oplus_{i=1}^{r}{I_ig_i}$ be a monomial submodule of F. The almost lex
module associated to M is  the monomial module
$M^{alex}=\oplus_{i=1}^{r}{J_ig_i}$ with $J_i=\mathrm{lexIdeal}\ I_i$ for each
$i$, i.e., the lex ideal associated to $I_i$ for each $i.$

Example:

+-----------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]             |
|                                                           |
|o1 = E                                                     |
|                                                           |
|o1 : PolynomialRing, 4 skew commutative variable(s)        |
+-----------------------------------------------------------+
|i2 : F=E^{0,0}                                             |
|                                                           |
|      2                                                    |
|o2 = E                                                     |
|                                                           |
|o2 : E-module, free                                        |
+-----------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                    |
|                                                           |
|o3 = ideal (e e , e e , e e )                              |
|             1 2   1 3   2 3                               |
|                                                           |
|o3 : Ideal of E                                            |
+-----------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3)                            |
|                                                           |
|o4 = ideal (e e , e e )                                    |
|             1 2   1 3                                     |
|                                                           |
|o4 : Ideal of E                                            |
+-----------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                           |
|                                                           |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |          |
|           | 0      0      0      e_1e_3 e_1e_2 |          |
|                                                           |
|                             2                             |
|o5 : E-module, submodule of E                              |
+-----------------------------------------------------------+
|i6 : almostLexModule M                                     |
|                                                           |
|o6 = image | e_1e_4 e_1e_3 e_1e_2 e_2e_3e_4 0      0      ||
|           | 0      0      0      0         e_1e_3 e_1e_2 ||
|                                                           |
|                             2                             |
|o6 : E-module, submodule of E                              |
+-----------------------------------------------------------+

See also
========

  * isAlmostLexModule -- whether a monomial module
    over an exterior algebra is almost lex
  * lexIdeal (ExteriorIdeals) -- compute the lex ideal with a
    given Hilbert function in an exterior algebra

Ways to use almostLexModule:
============================

  * "almostLexModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:634:0.

almostStableModule -- compute the smallest almost stable module containing a given monomial module
**************************************************************************************************

  * Usage:
        almostStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the smallest almost stable
        submodule of the ambient module containing M

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F and let
$M=\oplus_{i=1}^{r}{I_ig_i}$ a monomial submodule of F. The almost stable
module associated to M is  the monomial module $M_{s}=\oplus_{i=1}^{r}{J_ig_i}$
with $J_i=\mathrm{stableIdeal}\ I_i$ for each $i$, i.e., the stable ideal
associated to $I_i$ for each $i.$

Example:

+---------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]     |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : F=E^{0,0}                                     |
|                                                   |
|      2                                            |
|o2 = E                                             |
|                                                   |
|o2 : E-module, free                                |
+---------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3)                    |
|                                                   |
|o3 = ideal (e e , e e )                            |
|             1 2   1 3                             |
|                                                   |
|o3 : Ideal of E                                    |
+---------------------------------------------------+
|i4 : I_2=ideal(e_1*e_3,e_2*e_3)                    |
|                                                   |
|o4 = ideal (e e , e e )                            |
|             1 3   2 3                             |
|                                                   |
|o4 : Ideal of E                                    |
+---------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                   |
|                                                   |
|o5 = image | e_1e_3 e_1e_2 0      0      |         |
|           | 0      0      e_2e_3 e_1e_3 |         |
|                                                   |
|                             2                     |
|o5 : E-module, submodule of E                      |
+---------------------------------------------------+
|i6 : N=almostStableModule M                        |
|                                                   |
|o6 = image | e_1e_3 e_1e_2 0      0      0      |  |
|           | 0      0      e_2e_3 e_1e_3 e_1e_2 |  |
|                                                   |
|                             2                     |
|o6 : E-module, submodule of E                      |
+---------------------------------------------------+

See also
========

  * isAlmostStableModule -- whether a monomial
    module over an exterior algebra is almost stable

Ways to use almostStableModule:
===============================

  * "almostStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:801:0.

almostStronglyStableModule -- compute the smallest almost strongly stable module containing a given monomial module
*******************************************************************************************************************

  * Usage:
        almostStronglyStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the smallest almost strongly
        stable submodule of the ambient module containing M

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F and let
$M=\oplus_{i=1}^{r}{I_ig_i}$ a monomial submodule of F. The almost strongly
stable module associated to M is  the monomial module
$M_{ss}=\oplus_{i=1}^{r}{J_ig_i}$ with $J_i=\mathrm{stronglyStableIdeal}\ I_i$
for each $i$, i.e., the strongly stable ideal associated to $I_i$ for each $i.$

Example:

+--------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]          |
|                                                        |
|o1 = E                                                  |
|                                                        |
|o1 : PolynomialRing, 4 skew commutative variable(s)     |
+--------------------------------------------------------+
|i2 : F=E^{0,0}                                          |
|                                                        |
|      2                                                 |
|o2 = E                                                  |
|                                                        |
|o2 : E-module, free                                     |
+--------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                 |
|                                                        |
|o3 = ideal (e e , e e , e e )                           |
|             1 2   1 3   2 3                            |
|                                                        |
|o3 : Ideal of E                                         |
+--------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_4)                         |
|                                                        |
|o4 = ideal (e e , e e )                                 |
|             1 2   1 4                                  |
|                                                        |
|o4 : Ideal of E                                         |
+--------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                        |
|                                                        |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |       |
|           | 0      0      0      e_1e_4 e_1e_2 |       |
|                                                        |
|                             2                          |
|o5 : E-module, submodule of E                           |
+--------------------------------------------------------+
|i6 : N=almostStronglyStableModule M                     |
|                                                        |
|o6 = image | e_2e_3 e_1e_3 e_1e_2 0      0      0      ||
|           | 0      0      0      e_1e_4 e_1e_3 e_1e_2 ||
|                                                        |
|                             2                          |
|o6 : E-module, submodule of E                           |
+--------------------------------------------------------+

See also
========

  * isAlmostStronglyStableModule, --
    whether a monomial module over an exterior algebra is almost strongly
    stable

Ways to use almostStronglyStableModule:
=======================================

  * "almostStronglyStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:759:0.

bassNumbers -- compute the Bass numbers of a given graded module
****************************************************************

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

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

If M is a graded finitely generated module over an exterior algebra E, we
denote by $\beta_{i,j}(M)=\dim_K\mathrm{Tor}_{i}^{E}(M,K)_j$ the graded Betti
numbers of M and by $\mu_{i,j}(M) = \dim_K \mathrm{Ext}_E^i(K, M)_j$ the graded
Bass numbers of M. Let $M^\ast$ be the right (left) $E$-module
$\mathrm{Hom}_E(M,E).$ The duality between projective and injective resolutions
implies the following relation between the graded Bass numbers of a module and
the graded Betti numbers of its dual: $\beta_{i,j}(M) = \mu_{i,n-j}(M^\ast)$,
for all $i, j.$

Example:

+---------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]          |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : F=E^{0,0}                                     |
|                                                   |
|      2                                            |
|o2 = E                                             |
|                                                   |
|o2 : E-module, free                                |
+---------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)            |
|                                                   |
|o3 = ideal (e e , e e , e e )                      |
|             1 2   1 3   2 3                       |
|                                                   |
|o3 : Ideal of E                                    |
+---------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3)                    |
|                                                   |
|o4 = ideal (e e , e e )                            |
|             1 2   1 3                             |
|                                                   |
|o4 : Ideal of E                                    |
+---------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                   |
|                                                   |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |  |
|           | 0      0      0      e_1e_3 e_1e_2 |  |
|                                                   |
|                             2                     |
|o5 : E-module, submodule of E                      |
+---------------------------------------------------+
|i6 : bassNumbers(M, LengthLimit => 5)              |
|                                                   |
|            0 1  2  3  4  5                        |
|o6 = total: 2 5 12 22 35 51                        |
|         0: 2 1  1  1  1  1                        |
|         1: . 4 11 21 34 50                        |
|                                                   |
|o6 : BettiTally                                    |
+---------------------------------------------------+

Ways to use bassNumbers:
========================

  * "bassNumbers(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:952:0.

createModule -- create a module over an exterior algebra from a list of ideals in input
***************************************************************************************

  * Usage:
        createModule(L,F)
  * Inputs:
      * L, a list of ideals
      * F, a free module
  * Outputs:
      * a module (Macaulay2Doc), the submodule of F which is a
        direct sum of submodules determined by the ideals in L

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F and let be
$L=\{I_1,I_2,\ldots,I_r\}$. This method yields the following submodule of F:
$I_1 g_1 \oplus I_2 g_2 \oplus \cdots \oplus I_r g_r$.

Example:

+-------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]         |
|                                                       |
|o1 = E                                                 |
|                                                       |
|o1 : PolynomialRing, 4 skew commutative variable(s)    |
+-------------------------------------------------------+
|i2 : F=E^{0,0,0}                                       |
|                                                       |
|      3                                                |
|o2 = E                                                 |
|                                                       |
|o2 : E-module, free                                    |
+-------------------------------------------------------+
|i3 : I_1=ideal {e_1*e_2,e_3*e_4};                      |
|                                                       |
|o3 : Ideal of E                                        |
+-------------------------------------------------------+
|i4 : I_2=ideal {e_1*e_2,e_2*e_3*e_4};                  |
|                                                       |
|o4 : Ideal of E                                        |
+-------------------------------------------------------+
|i5 : I_3=ideal {e_2*e_3*e_4};                          |
|                                                       |
|o5 : Ideal of E                                        |
+-------------------------------------------------------+
|i6 : l={I_1,I_2,I_3};                                  |
+-------------------------------------------------------+
|i7 : M=createModule(l,F)                               |
|                                                       |
|o7 = image | e_3e_4 e_1e_2 0      0         0         ||
|           | 0      0      e_1e_2 e_2e_3e_4 0         ||
|           | 0      0      0      0         e_2e_3e_4 ||
|                                                       |
|                             3                         |
|o7 : E-module, submodule of E                          |
+-------------------------------------------------------+

Caveat
======

ideals and their number have to be compatible with ambient free module

See also
========

  * getIdeals -- get component ideals from a monomial module

Ways to use createModule:
=========================

  * "createModule(List,Module)"

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

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

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

The source of this document is in ExteriorModules.m2:536:0.

getIdeals -- get component ideals from a monomial module
********************************************************

  * Usage:
        getIdeals M
  * Inputs:
      * M, a monomial submodule of the ambient module over an exterior algebra
  * Outputs:
      * a list (Macaulay2Doc), list of ideals that determine the
        submodules whose direct sum is M

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

Let M be a submodule of F and let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of
F. This method returns a list $L=\{I_1,I_2,\ldots,I_r\}$ such that $M=I_i g_i
\oplus I_2 g_2 \oplus \cdots \oplus I_r g_r$.

Example:

+-----------------------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                               |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : m=matrix {{e_1*e_2,e_3*e_4,0,0,0},{0,0,e_1*e_2,e_2*e_3*e_4,0},{0,0,0,0,e|
|                                                                             |
|o2 = | e_1e_2 e_3e_4 0      0         0         |                            |
|     | 0      0      e_1e_2 e_2e_3e_4 0         |                            |
|     | 0      0      0      0         e_2e_3e_4 |                            |
|                                                                             |
|             3      5                                                        |
|o2 : Matrix E  <-- E                                                         |
|-----------------------------------------------------------------------------|
|_2*e_3*e_4}}                                                                 |
+-----------------------------------------------------------------------------+
|i3 : M=image m                                                               |
|                                                                             |
|o3 = image | e_1e_2 e_3e_4 0      0         0         |                      |
|           | 0      0      e_1e_2 e_2e_3e_4 0         |                      |
|           | 0      0      0      0         e_2e_3e_4 |                      |
|                                                                             |
|                             3                                               |
|o3 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+
|i4 : getIdeals M                                                             |
|                                                                             |
|o4 = {ideal (e e , e e ), ideal (e e , e e e ), ideal(e e e )}               |
|              3 4   1 2           1 2   2 3 4          2 3 4                 |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * createModule -- create a module over an exterior
    algebra from a list of ideals in input

Ways to use getIdeals:
======================

  * "getIdeals(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:554:0.

hilbertSequence(Module) -- compute the Hilbert sequence of a given module over an exterior algebra
**************************************************************************************************

  * Function: hilbertSequence (ExteriorIdeals),
  * Usage:
        hilbertSequence M
  * Inputs:
      * M, a module (Macaulay2Doc), a module over an exterior
        algebra E
  * Outputs:
      * a list (Macaulay2Doc), nonnegative integers representing
        the Hilbert sequence of the quotient F/M

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F with $deg(g_i)=f_i,\ i=1,
\ldots, r.$ Given $\sum_{i=f_1}^{n+f_r}{h_i t^i}$ the Hilbert series of a
graded E-module $F/M$, the sequence $(h_{f_1},\ldots,h_{n+f_r})$ is called the
Hilbert sequence of $F/M.$

Example:

+-----------------------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                               |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : M=image matrix {{e_1*e_2,e_3*e_4,0,0,0},{0,0,e_1*e_2,e_2*e_3*e_4,0},{0,0|
|                                                                             |
|o2 = image | e_1e_2 e_3e_4 0      0         0         |                      |
|           | 0      0      e_1e_2 e_2e_3e_4 0         |                      |
|           | 0      0      0      0         e_2e_3e_4 |                      |
|                                                                             |
|                             3                                               |
|o2 : E-module, submodule of E                                                |
|-----------------------------------------------------------------------------|
|,0,0,e_2*e_3*e_4}}                                                           |
+-----------------------------------------------------------------------------+
|i3 : hilbertSequence M                                                       |
|                                                                             |
|o3 = {3, 12, 15, 4, 0}                                                       |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

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

  * hilbertSequence(Module) -- compute the
    Hilbert sequence of a given module over an exterior algebra
-------------------------------------------------------------------------------

The source of this document is in ExteriorModules.m2:570:0.

initialModule -- compute the initial module of a given module
*************************************************************

  * Usage:
        initialModule M
  * Inputs:
      * M, a module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the initial module of the module
        M with default monomial order

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

Let $F$ a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}.$ The
elements $e_{\sigma}g_i$ with $e_{\sigma}$ a monomial of $E$ are called
monomials of $F$ and $\mathrm{deg}(e_{\sigma} g_i) = \mathrm{deg}(e_{\sigma}) +
\mathrm{deg}(g_i).$ Any element $f$ of $F$ is a unique linear combination of
monomials with coefficients in $K$. Let > be a monomial order on $E$. The
largest monomial of $f$ is called the initial monomial of $f$ and it is denoted
by $\mathrm{In}(f)$. If M is a graded submodule of $F$ then the submodule of
initial terms of M, denoted by $\mathrm{In}(M)$, is the submodule of $F$
generated by the initial terms of elements of M.

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_3,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                               |
|                                                                             |
|      2                                                                      |
|o2 = E                                                                       |
|                                                                             |
|o2 : E-module, free                                                          |
+-----------------------------------------------------------------------------+
|i3 : f_1=(e_1*e_2)*F_0                                                       |
|                                                                             |
|o3 = | e_1e_2 |                                                              |
|     |    0   |                                                              |
|                                                                             |
|      2                                                                      |
|o3 : E                                                                       |
+-----------------------------------------------------------------------------+
|i4 : f_2=(e_1*e_3)*F_0+(e_2*e_3)*F_1                                         |
|                                                                             |
|o4 = | e_1e_3 |                                                              |
|     | e_2e_3 |                                                              |
|                                                                             |
|      2                                                                      |
|o4 : E                                                                       |
+-----------------------------------------------------------------------------+
|i5 : f_3=(e_1*e_2*e_3)*F_1                                                   |
|                                                                             |
|o5 = |     0     |                                                           |
|     | e_1e_2e_3 |                                                           |
|                                                                             |
|      2                                                                      |
|o5 : E                                                                       |
+-----------------------------------------------------------------------------+
|i6 : M=image map(F,E^{-degree f_1,-degree f_2,-degree f_3},matrix            |
|                                                                             |
|o6 = image | e_1e_2 e_1e_3 0         |                                       |
|           | 0      e_2e_3 e_1e_2e_3 |                                       |
|                                                                             |
|                             2                                               |
|o6 : E-module, submodule of E                                                |
|-----------------------------------------------------------------------------|
|{f_1,f_2,f_3})                                                               |
+-----------------------------------------------------------------------------+
|i7 : initialModule M                                                         |
|                                                                             |
|o7 = image | 0         e_1e_2 e_1e_3 |                                       |
|           | e_1e_2e_3 0      0      |                                       |
|                                                                             |
|                             2                                               |
|o7 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+

See also
========

  * isMonomialModule -- whether a module is monomial

Ways to use initialModule:
==========================

  * "initialModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:932:0.

isAlmostLexModule -- whether a monomial module over an exterior algebra is almost lex
*************************************************************************************

  * Usage:
        isAlmostLexModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        almost lex

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F. A monomial submodule
$M=\oplus_{i=1} ^{r}{I_ig_i}$ of F is almost lex if $I_i$ is a lex ideal of E
for each $i.$

Example:

+---------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]     |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : F=E^{0,0}                                     |
|                                                   |
|      2                                            |
|o2 = E                                             |
|                                                   |
|o2 : E-module, free                                |
+---------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3)                    |
|                                                   |
|o3 = ideal (e e , e e )                            |
|             1 2   1 3                             |
|                                                   |
|o3 : Ideal of E                                    |
+---------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3,e_2*e_3)            |
|                                                   |
|o4 = ideal (e e , e e , e e )                      |
|             1 2   1 3   2 3                       |
|                                                   |
|o4 : Ideal of E                                    |
+---------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                   |
|                                                   |
|o5 = image | e_1e_3 e_1e_2 0      0      0      |  |
|           | 0      0      e_2e_3 e_1e_3 e_1e_2 |  |
|                                                   |
|                             2                     |
|o5 : E-module, submodule of E                      |
+---------------------------------------------------+
|i6 : isAlmostLexModule M                           |
|                                                   |
|o6 = false                                         |
+---------------------------------------------------+
|i7 : I_3=ideal(e_1*e_2,e_1*e_3, e_1*e_4)           |
|                                                   |
|o7 = ideal (e e , e e , e e )                      |
|             1 2   1 3   1 4                       |
|                                                   |
|o7 : Ideal of E                                    |
+---------------------------------------------------+
|i8 : isAlmostLexModule createModule({I_1,I_3},F)   |
|                                                   |
|o8 = true                                          |
+---------------------------------------------------+

See also
========

  * almostLexModule -- compute an almost lex module
    with the same Hilbert sequence of the module in input

Ways to use isAlmostLexModule:
==============================

  * "isAlmostLexModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:614:0.

isAlmostStableModule -- whether a monomial module over an exterior algebra is almost stable
*******************************************************************************************

  * Usage:
        isAlmostStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        almost stable

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F. A monomial submodule
$M=\oplus_{i=1}^{r}{I_ig_i}$ of F is almost stable if $I_i$ is a stable ideal
of E for each $i.$

Example:

+---------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]     |
|                                                   |
|o1 = E                                             |
|                                                   |
|o1 : PolynomialRing, 4 skew commutative variable(s)|
+---------------------------------------------------+
|i2 : F=E^{0,0}                                     |
|                                                   |
|      2                                            |
|o2 = E                                             |
|                                                   |
|o2 : E-module, free                                |
+---------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3)                    |
|                                                   |
|o3 = ideal (e e , e e )                            |
|             1 2   1 3                             |
|                                                   |
|o3 : Ideal of E                                    |
+---------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_2*e_3)                    |
|                                                   |
|o4 = ideal (e e , e e )                            |
|             1 2   2 3                             |
|                                                   |
|o4 : Ideal of E                                    |
+---------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                   |
|                                                   |
|o5 = image | e_1e_3 e_1e_2 0      0      |         |
|           | 0      0      e_2e_3 e_1e_2 |         |
|                                                   |
|                             2                     |
|o5 : E-module, submodule of E                      |
+---------------------------------------------------+
|i6 : isAlmostStableModule M                        |
|                                                   |
|o6 = true                                          |
+---------------------------------------------------+
|i7 : I_3=ideal(e_1*e_3,e_2*e_3)                    |
|                                                   |
|o7 = ideal (e e , e e )                            |
|             1 3   2 3                             |
|                                                   |
|o7 : Ideal of E                                    |
+---------------------------------------------------+
|i8 : isAlmostStableModule createModule({I_1,I_3},F)|
|                                                   |
|o8 = false                                         |
+---------------------------------------------------+

See also
========

  * almostStableModule -- compute the smallest
    almost stable module containing a given monomial module

Ways to use isAlmostStableModule:
=================================

  * "isAlmostStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:781:0.

isAlmostStronglyStableModule -- whether a monomial module over an exterior algebra is almost strongly stable
************************************************************************************************************

  * Usage:
        isAlmostStronglyStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        almost strongly stable

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F. A monomial submodule
$M=\oplus_{i=1}^{r}{I_ig_i}$ of F is almost strongly stable if $I_i$ is a
strongly stable ideal of E for each $i.$

Example:

+-----------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]             |
|                                                           |
|o1 = E                                                     |
|                                                           |
|o1 : PolynomialRing, 4 skew commutative variable(s)        |
+-----------------------------------------------------------+
|i2 : F=E^{0,0}                                             |
|                                                           |
|      2                                                    |
|o2 = E                                                     |
|                                                           |
|o2 : E-module, free                                        |
+-----------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                    |
|                                                           |
|o3 = ideal (e e , e e , e e )                              |
|             1 2   1 3   2 3                               |
|                                                           |
|o3 : Ideal of E                                            |
+-----------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3)                            |
|                                                           |
|o4 = ideal (e e , e e )                                    |
|             1 2   1 3                                     |
|                                                           |
|o4 : Ideal of E                                            |
+-----------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                           |
|                                                           |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |          |
|           | 0      0      0      e_1e_3 e_1e_2 |          |
|                                                           |
|                             2                             |
|o5 : E-module, submodule of E                              |
+-----------------------------------------------------------+
|i6 : isAlmostStronglyStableModule M                        |
|                                                           |
|o6 = true                                                  |
+-----------------------------------------------------------+
|i7 : I_3=ideal(e_1*e_2,e_1*e_4)                            |
|                                                           |
|o7 = ideal (e e , e e )                                    |
|             1 2   1 4                                     |
|                                                           |
|o7 : Ideal of E                                            |
+-----------------------------------------------------------+
|i8 : isAlmostStronglyStableModule createModule({I_1,I_3},F)|
|                                                           |
|o8 = false                                                 |
+-----------------------------------------------------------+

See also
========

  * almostStronglyStableModule -- compute
    the smallest almost strongly stable module containing a given monomial
    module

Ways to use isAlmostStronglyStableModule:
=========================================

  * "isAlmostStronglyStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:739:0.

isHilbertSequence(List,Module) -- whether the given sequence is a Hilbert sequence
**********************************************************************************

  * Function: isHilbertSequence (ExteriorIdeals),
  * Usage:
        isHilbertSequence(hs,F)
  * Inputs:
      * hs, a list (Macaulay2Doc), a list of integers
      * F, a module (Macaulay2Doc), a free module over an
        exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the sequence hs
        satisfies the generalization of the Kruskal-Katona theorem in the free
        module F

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

Let $F$ a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\},$ with
$deg(g_i)=f_i,\ i=1, \ldots, r.$ If $M$ is a graded submodule of F, and
$H_{F/M}(t) =\sum_{i=f_1}^{f_r+n}H_{F/M}(i)t^i$ is the Hilbert series of $F/M,$
then the sequence $(H_{F/M}(f_1), H_{F/M}(f_1+1), \ldots, H_{F/M}(f_r+n))\in
\mathbb{N}_0^{f_r+n-f_1+1}$ is called the Hilbert sequence of $F/M$ and we
denote it by $Hs_{F/M}.$ The integers $f_1, f_1+1, \ldots, f_r+n$ are called
the $Hs_{F/M}$-degrees.

Example:

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

See also
========

  * lexModule -- compute the lex submodule with a given
    Hilbert sequence in a free module

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

  * isHilbertSequence(List,Module),
    -- whether the given sequence is a Hilbert sequence
-------------------------------------------------------------------------------

The source of this document is in ExteriorModules.m2:676:0.

isLexModule -- whether a monomial module over an exterior algebra is lex
************************************************************************

  * Usage:
        isLexModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        lex

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

A monomial module M is lex if for all monomials $u,v$ of F of the same degree
with $v\in M$ and $u>v$ (> lex order) then $u\in M$. An equivalent definition
of a lex submodule is the following one: a monomial submodule
$M=\oplus_{i=1}^{r}{I_ig_i}$ of F is lex if $I_i$ is a lex ideal of E for each
$i,$ and $(e_1,\dots, e_n)^{\rho_i + f_i - f_{i-1}} \subseteq I_{i-1}$ for $i =
2, \dots, r$ with $\rho_i = \mathrm{indeg}\ I_i.$

Example:

+--------------------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                            |
|                                                                          |
|o1 = E                                                                    |
|                                                                          |
|o1 : PolynomialRing, 4 skew commutative variable(s)                       |
+--------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                            |
|                                                                          |
|      2                                                                   |
|o2 = E                                                                    |
|                                                                          |
|o2 : E-module, free                                                       |
+--------------------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                                   |
|                                                                          |
|o3 = ideal (e e , e e , e e )                                             |
|             1 2   1 3   2 3                                              |
|                                                                          |
|o3 : Ideal of E                                                           |
+--------------------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3)                                           |
|                                                                          |
|o4 = ideal (e e , e e )                                                   |
|             1 2   1 3                                                    |
|                                                                          |
|o4 : Ideal of E                                                           |
+--------------------------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                                          |
|                                                                          |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |                         |
|           | 0      0      0      e_1e_3 e_1e_2 |                         |
|                                                                          |
|                             2                                            |
|o5 : E-module, submodule of E                                             |
+--------------------------------------------------------------------------+
|i6 : Malex=almostLexModule M                                              |
|                                                                          |
|o6 = image | e_1e_4 e_1e_3 e_1e_2 e_2e_3e_4 0      0      |               |
|           | 0      0      0      0         e_1e_3 e_1e_2 |               |
|                                                                          |
|                             2                                            |
|o6 : E-module, submodule of E                                             |
+--------------------------------------------------------------------------+
|i7 : isLexModule Malex                                                    |
|                                                                          |
|o7 = false                                                                |
+--------------------------------------------------------------------------+
|i8 : L=createModule({ideal(e_1*e_2,e_1*e_3*e_4),ideal(e_1*e_2*e_3*e_4)},F)|
|                                                                          |
|o8 = image | e_1e_2 e_1e_3e_4 0            |                              |
|           | 0      0         e_1e_2e_3e_4 |                              |
|                                                                          |
|                             2                                            |
|o8 : E-module, submodule of E                                             |
+--------------------------------------------------------------------------+
|i9 : isLexModule L                                                        |
|                                                                          |
|o9 = true                                                                 |
+--------------------------------------------------------------------------+

See also
========

  * lexModule -- compute the lex submodule with a given
    Hilbert sequence in a free module

Ways to use isLexModule:
========================

  * "isLexModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:657:0.

isMonomialModule -- whether a module is monomial
************************************************

  * Usage:
        isMonomialModule M
  * Inputs:
      * M, a monomial submodule of the ambient module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        monomial

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

Let $F$ a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}.$ The
elements $e_{\sigma}g_i$ with $e_{\sigma}$ a monomial of $E$ are called
monomials of $F$ and $\mathrm{deg}(e_{\sigma} g_i) = \mathrm{deg}(e_{\sigma}) +
\mathrm{deg}(g_i).$ A graded submodule M of $F$ is a monomial submodule if M is
a submodule generated by monomials of $F$, i.e., $M=I_i g_i \oplus I_2 g_2
\oplus \cdots \oplus I_r g_r,$ where $I_i$ is a monomial ideal of $E$ for each
$i.$

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_3,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                               |
|                                                                             |
|      2                                                                      |
|o2 = E                                                                       |
|                                                                             |
|o2 : E-module, free                                                          |
+-----------------------------------------------------------------------------+
|i3 : f_1=(e_1*e_2)*F_0                                                       |
|                                                                             |
|o3 = | e_1e_2 |                                                              |
|     |    0   |                                                              |
|                                                                             |
|      2                                                                      |
|o3 : E                                                                       |
+-----------------------------------------------------------------------------+
|i4 : f_2=(e_1*e_3)*F_0+(e_2*e_3)*F_1                                         |
|                                                                             |
|o4 = | e_1e_3 |                                                              |
|     | e_2e_3 |                                                              |
|                                                                             |
|      2                                                                      |
|o4 : E                                                                       |
+-----------------------------------------------------------------------------+
|i5 : f_3=(e_1*e_2*e_3)*F_1                                                   |
|                                                                             |
|o5 = |     0     |                                                           |
|     | e_1e_2e_3 |                                                           |
|                                                                             |
|      2                                                                      |
|o5 : E                                                                       |
+-----------------------------------------------------------------------------+
|i6 : M=image map(F,E^{-degree f_1,-degree f_2,-degree f_3},matrix            |
|                                                                             |
|o6 = image | e_1e_2 e_1e_3 0         |                                       |
|           | 0      e_2e_3 e_1e_2e_3 |                                       |
|                                                                             |
|                             2                                               |
|o6 : E-module, submodule of E                                                |
|-----------------------------------------------------------------------------|
|{f_1,f_2,f_3})                                                               |
+-----------------------------------------------------------------------------+
|i7 : isMonomialModule M                                                      |
|                                                                             |
|o7 = false                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * initialModule -- compute the initial module of a
    given module

Ways to use isMonomialModule:
=============================

  * "isMonomialModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:591:0.

isStableModule -- whether a monomial module over an exterior algebra is stable
******************************************************************************

  * Usage:
        isStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        stable

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F with $deg(g_i)=f_i,\
i=1,\ldots,r.$ A monomial submodule $M=\oplus_{i=1}^{r}{I_ig_i}$ of F is stable
if it is almost stable and $(x_1,\ldots,x_n)^{(f_{i+1}-f_i)} I_{i+1}$ belongs
to $I_i$ for $i=1,\ldots,r-1.$ A monomial ideal $I$ of $E$ is called stable if
for each monomial $e_{\sigma}\in I$ and each $j < \mathrm{m}(e_{\sigma})$ one
has $e_j e_{{\sigma} \setminus \{\mathrm{m}(e_{\sigma})\}} \in I.$

Example:

+--------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                |
|                                                              |
|o1 = E                                                        |
|                                                              |
|o1 : PolynomialRing, 4 skew commutative variable(s)           |
+--------------------------------------------------------------+
|i2 : F=E^{0,0}                                                |
|                                                              |
|      2                                                       |
|o2 = E                                                        |
|                                                              |
|o2 : E-module, free                                           |
+--------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2)                                       |
|                                                              |
|o3 = ideal(e e )                                              |
|            1 2                                               |
|                                                              |
|o3 : Ideal of E                                               |
+--------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2*e_3,e_1*e_2*e_4,e_1*e_3*e_4)           |
|                                                              |
|o4 = ideal (e e e , e e e , e e e )                           |
|             1 2 3   1 2 4   1 3 4                            |
|                                                              |
|o4 : Ideal of E                                               |
+--------------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                              |
|                                                              |
|o5 = image | e_1e_2 0         0         0         |           |
|           | 0      e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 |           |
|                                                              |
|                             2                                |
|o5 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i6 : isAlmostStableModule M                                   |
|                                                              |
|o6 = true                                                     |
+--------------------------------------------------------------+
|i7 : isStableModule M                                         |
|                                                              |
|o7 = false                                                    |
+--------------------------------------------------------------+

See also
========

  * isAlmostStableModule -- whether a monomial
    module over an exterior algebra is almost stable
  * stableModule -- compute the smallest stable module
    containing a given monomial module

Ways to use isStableModule:
===========================

  * "isStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:865:0.

isStronglyStableModule -- whether a monomial module over an exterior algebra is strongly stable
***********************************************************************************************

  * Usage:
        isStronglyStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the module M is
        strongly stable

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

Let $\{g_1,g_2,\ldots,g_r\}$ be a graded basis of F with $deg(g_i)=f_i,\
i=1,\ldots,r.$ A monomial submodule $M=\oplus_{i=1}^{r}{I_ig_i}$ of F is
strongly stable if it is almost strongly stable and
$(x_1,\ldots,x_n)^{(f_{i+1}-f_i)} I_{i+1}$ belongs to $I_i$ for
$i=1,\ldots,r-1.$ A monomial ideal $I$ of $E$ is called strongly stable if for
each monomial $e_{\sigma} \in I$ and each $j \in \sigma$ one has $e_ie_{\sigma
\setminus \{j\}} \in I$ for all $i<j.$

Example:

+--------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                |
|                                                              |
|o1 = E                                                        |
|                                                              |
|o1 : PolynomialRing, 4 skew commutative variable(s)           |
+--------------------------------------------------------------+
|i2 : F=E^{0,0}                                                |
|                                                              |
|      2                                                       |
|o2 = E                                                        |
|                                                              |
|o2 : E-module, free                                           |
+--------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2)                                       |
|                                                              |
|o3 = ideal(e e )                                              |
|            1 2                                               |
|                                                              |
|o3 : Ideal of E                                               |
+--------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2*e_3,e_1*e_2*e_4,e_1*e_3*e_4)           |
|                                                              |
|o4 = ideal (e e e , e e e , e e e )                           |
|             1 2 3   1 2 4   1 3 4                            |
|                                                              |
|o4 : Ideal of E                                               |
+--------------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                              |
|                                                              |
|o5 = image | e_1e_2 0         0         0         |           |
|           | 0      e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 |           |
|                                                              |
|                             2                                |
|o5 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i6 : isAlmostStronglyStableModule M                           |
|                                                              |
|o6 = true                                                     |
+--------------------------------------------------------------+
|i7 : isStronglyStableModule M                                 |
|                                                              |
|o7 = false                                                    |
+--------------------------------------------------------------+

See also
========

  * isAlmostStronglyStableModule, --
    whether a monomial module over an exterior algebra is almost strongly
    stable
  * stronglyStableModule -- compute the smallest
    strongly stable module containing a given monomial module

Ways to use isStronglyStableModule:
===================================

  * "isStronglyStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:822:0.

lexModule -- compute the lex submodule with a given Hilbert sequence in a free module
*************************************************************************************

  * Usage:
        lexModule(hs,F) or lexModule M
  * Inputs:
      * hs, a list of integers
      * F, a free module over an exterior algebra
      * M, a monomial submodule of a free module
  * Outputs:
      * a module (Macaulay2Doc), the lex submodule of the ambient
        module with Hilbert sequence hs or the lex submodule of the ambient
        module with the same Hilbert sequence of M

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

Let $F$ a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}.$ If $M$
is a graded submodule of F, as a consequence of a generalization of the
Kruskal-Katona theorem, then there exists a unique lex submodule of F with the
same Hilbert function as M. If M is a monomial submodule of F, we denote by
$M^\mathrm{lex}$ the unique lex submodule of F with the same Hilbert function
as M. $M^\mathrm{lex}$ is called the lex submodule associated to M. This
construction uses the generalization of the Kruskal-Katona theorem.

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                               |
|                                                                             |
|      2                                                                      |
|o2 = E                                                                       |
|                                                                             |
|o2 : E-module, free                                                          |
+-----------------------------------------------------------------------------+
|i3 : lexModule({2,8,3,1,0},F)                                                |
|                                                                             |
|o3 = image | e_3e_4 e_2e_4 e_1e_4 e_2e_3 e_1e_3 e_1e_2 0      0      0      ||
|           | 0      0      0      0      0      0      e_1e_4 e_1e_3 e_1e_2 ||
|                                                                             |
|                             2                                               |
|o3 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+
|i4 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                                      |
|                                                                             |
|o4 = ideal (e e , e e , e e )                                                |
|             1 2   1 3   2 3                                                 |
|                                                                             |
|o4 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i5 : I_2=ideal(e_1*e_2,e_1*e_3)                                              |
|                                                                             |
|o5 = ideal (e e , e e )                                                      |
|             1 2   1 3                                                       |
|                                                                             |
|o5 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i6 : M=createModule({I_1,I_2},F)                                             |
|                                                                             |
|o6 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |                            |
|           | 0      0      0      e_1e_3 e_1e_2 |                            |
|                                                                             |
|                             2                                               |
|o6 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+
|i7 : Mlex=lexModule M                                                        |
|                                                                             |
|o7 = image | e_2e_4 e_1e_4 e_2e_3 e_1e_3 e_1e_2 0         0         0        |
|           | 0      0      0      0      0      e_1e_3e_4 e_1e_2e_4 e_1e_2e_3|
|                                                                             |
|                             2                                               |
|o7 : E-module, submodule of E                                                |
|-----------------------------------------------------------------------------|
||                                                                            |
||                                                                            |
+-----------------------------------------------------------------------------+

See also
========

  * isLexModule -- whether a monomial module over an
    exterior algebra is lex
  * isHilbertSequence (ExteriorIdeals) -- whether the
    given sequence is a Hilbert sequence
  * lexModuleBySequences -- alternative algorithm
    to compute the lex submodule with a given Hilbert sequence in a free module

Ways to use lexModule:
======================

  * "lexModule(List,Module)"
  * "lexModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:699:0.

lexModuleBySequences -- alternative algorithm to compute the lex submodule with a given Hilbert sequence in a free module
*************************************************************************************************************************

  * Usage:
        lexModuleBySequences(hs,F)
  * Inputs:
      * hs, a list of integers
      * F, a free module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the lex submodule of the free
        module F with Hilbert sequence hs

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

Let $F$ a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}.$ If $M$
is a graded submodule of F, as a consequence of a generalization of the
Kruskal-Katona theorem, then there exists a unique lex submodule of F with the
same Hilbert function as M. If M is a monomial submodule of F, we denote by
$M^\mathrm{lex}$ the unique lex submodule of F with the same Hilbert function
as M. $M^\mathrm{lex}$ is called the lex submodule associated to M. The
algorithmic construction of the lex submodule is based on the additive property
of Hilbert functions and on Kruskal-Katona's theorem

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                               |
|                                                                             |
|      2                                                                      |
|o2 = E                                                                       |
|                                                                             |
|o2 : E-module, free                                                          |
+-----------------------------------------------------------------------------+
|i3 : lexModuleBySequences({2,8,3,1,0},F)                                     |
|                                                                             |
|o3 = image | e_3e_4 e_2e_4 e_1e_4 e_2e_3 e_1e_3 e_1e_2 0      0      0      ||
|           | 0      0      0      0      0      0      e_1e_4 e_1e_3 e_1e_2 ||
|                                                                             |
|                             2                                               |
|o3 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+

See also
========

  * isLexModule -- whether a monomial module over an
    exterior algebra is lex
  * isHilbertSequence (ExteriorIdeals) -- whether the
    given sequence is a Hilbert sequence
  * lexModule -- compute the lex submodule with a given
    Hilbert sequence in a free module

Ways to use lexModuleBySequences:
=================================

  * "lexModuleBySequences(List,Module)"

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

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

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

The source of this document is in ExteriorModules.m2:717:0.

minimalBettiNumbers(Module) -- compute the minimal Betti numbers of a given graded module
*****************************************************************************************

  * Function: minimalBettiNumbers (ExteriorIdeals),
  * Usage:
        minimalBettiNumbers(M, LengthLimit => lim)
  * Inputs:
      * M, a module (Macaulay2Doc), a graded module over an
        exterior algebra
  * Optional inputs (Macaulay2Doc),:
      * LengthLimit (ExteriorIdeals), => 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
        module M computed using its minimal generators

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

If M is a graded finitely generated module over an exterior algebra E, we
denote by $\beta_{i,j}(M)=\dim_K\mathrm{Tor}_{i}^{E}(M,K)_j$ the graded Betti
numbers of M.

Example:

+-----------------------------------------------------------------------------+
|i1 : E=QQ[e_1..e_4,SkewCommutative=>true]                                    |
|                                                                             |
|o1 = E                                                                       |
|                                                                             |
|o1 : PolynomialRing, 4 skew commutative variable(s)                          |
+-----------------------------------------------------------------------------+
|i2 : F=E^{0,0}                                                               |
|                                                                             |
|      2                                                                      |
|o2 = E                                                                       |
|                                                                             |
|o2 : E-module, free                                                          |
+-----------------------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2,e_1*e_3,e_2*e_3)                                      |
|                                                                             |
|o3 = ideal (e e , e e , e e )                                                |
|             1 2   1 3   2 3                                                 |
|                                                                             |
|o3 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2,e_1*e_3)                                              |
|                                                                             |
|o4 = ideal (e e , e e )                                                      |
|             1 2   1 3                                                       |
|                                                                             |
|o4 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i5 : M_1=createModule({I_1,I_2},F)                                           |
|                                                                             |
|o5 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |                            |
|           | 0      0      0      e_1e_3 e_1e_2 |                            |
|                                                                             |
|                             2                                               |
|o5 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+
|i6 : J=ideal(join(flatten entries gens I_1,{e_1*e_2*e_3}))                   |
|                                                                             |
|o6 = ideal (e e , e e , e e , e e e )                                        |
|             1 2   1 3   2 3   1 2 3                                         |
|                                                                             |
|o6 : Ideal of E                                                              |
+-----------------------------------------------------------------------------+
|i7 : M_2=createModule({J,I_2},F)                                             |
|                                                                             |
|o7 = image | e_2e_3 e_1e_3 e_1e_2 0      0      |                            |
|           | 0      0      0      e_1e_3 e_1e_2 |                            |
|                                                                             |
|                             2                                               |
|o7 : E-module, submodule of E                                                |
+-----------------------------------------------------------------------------+
|i8 : M_1==M_2                                                                |
|                                                                             |
|o8 = true                                                                    |
+-----------------------------------------------------------------------------+
|i9 : betti M_1==betti M_2                                                    |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+
|i10 : minimalBettiNumbers(M_1, LengthLimit => 5) == minimalBettiNumbers(M_2, |
|                                                                             |
|o10 = true                                                                   |
|-----------------------------------------------------------------------------|
|LengthLimit => 5)                                                            |
+-----------------------------------------------------------------------------+

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

  * minimalBettiNumbers(Module), --
    compute the minimal Betti numbers of a given graded module
-------------------------------------------------------------------------------

The source of this document is in ExteriorModules.m2:911:0.

stableModule -- compute the smallest stable module containing a given monomial module
*************************************************************************************

  * Usage:
        stableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the smallest stable submodule of
        the ambient module containing M

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

Let $F$ be a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}$ and
let $M$ be a monomial submodule of F. This method allows the construction of
the smallest stable submodule of F containing M. It is useful, although it does
not preserve invariants. In fact, the computation by hand of a stable submodule
implies some tedious calculations overall in the case when the elements of  the
homogeneous basis of F have different degrees.

Example:

+--------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                |
|                                                              |
|o1 = E                                                        |
|                                                              |
|o1 : PolynomialRing, 4 skew commutative variable(s)           |
+--------------------------------------------------------------+
|i2 : F=E^{0,0}                                                |
|                                                              |
|      2                                                       |
|o2 = E                                                        |
|                                                              |
|o2 : E-module, free                                           |
+--------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2)                                       |
|                                                              |
|o3 = ideal(e e )                                              |
|            1 2                                               |
|                                                              |
|o3 : Ideal of E                                               |
+--------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2*e_3,e_1*e_2*e_4,e_1*e_3*e_4)           |
|                                                              |
|o4 = ideal (e e e , e e e , e e e )                           |
|             1 2 3   1 2 4   1 3 4                            |
|                                                              |
|o4 : Ideal of E                                               |
+--------------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                              |
|                                                              |
|o5 = image | e_1e_2 0         0         0         |           |
|           | 0      e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 |           |
|                                                              |
|                             2                                |
|o5 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i6 : isStableModule M                                         |
|                                                              |
|o6 = false                                                    |
+--------------------------------------------------------------+
|i7 : Ms=stableModule M                                        |
|                                                              |
|o7 = image | e_1e_2 e_1e_3e_4 0         0         0         | |
|           | 0      0         e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 | |
|                                                              |
|                             2                                |
|o7 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i8 : isStableModule Ms                                        |
|                                                              |
|o8 = true                                                     |
+--------------------------------------------------------------+

See also
========

  * isStableModule -- whether a monomial module over an
    exterior algebra is stable
  * isAlmostStableModule -- whether a monomial
    module over an exterior algebra is almost stable

Ways to use stableModule:
=========================

  * "stableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:887:0.

stronglyStableModule -- compute the smallest strongly stable module containing a given monomial module
******************************************************************************************************

  * Usage:
        stronglyStableModule M
  * Inputs:
      * M, a monomial module over an exterior algebra
  * Outputs:
      * a module (Macaulay2Doc), the smallest strongly stable
        submodule of the ambient module containing M

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

Let $F$ be a free module with homogeneous basis $\{g_1,g_2,\ldots,g_r\}$ and
let $M$ be a monomial submodule of F. This method allows the construction of
the smallest strongly stable submodule of F containing M. It is useful,
although it does not preserve invariants. In fact, the computation by hand of a
strongly stable submodule implies some tedious calculations overall in the case
when the elements of  the homogeneous basis of F have different degrees.
Furthermore, it is worth pointing out that such methods are analogous to the
Macaulay2 function borel that computes the smallest borel ideal containing a
given ideal.

Example:

+--------------------------------------------------------------+
|i1 : E = QQ[e_1..e_4, SkewCommutative => true]                |
|                                                              |
|o1 = E                                                        |
|                                                              |
|o1 : PolynomialRing, 4 skew commutative variable(s)           |
+--------------------------------------------------------------+
|i2 : F=E^{0,0}                                                |
|                                                              |
|      2                                                       |
|o2 = E                                                        |
|                                                              |
|o2 : E-module, free                                           |
+--------------------------------------------------------------+
|i3 : I_1=ideal(e_1*e_2)                                       |
|                                                              |
|o3 = ideal(e e )                                              |
|            1 2                                               |
|                                                              |
|o3 : Ideal of E                                               |
+--------------------------------------------------------------+
|i4 : I_2=ideal(e_1*e_2*e_3,e_1*e_2*e_4,e_1*e_3*e_4)           |
|                                                              |
|o4 = ideal (e e e , e e e , e e e )                           |
|             1 2 3   1 2 4   1 3 4                            |
|                                                              |
|o4 : Ideal of E                                               |
+--------------------------------------------------------------+
|i5 : M=createModule({I_1,I_2},F)                              |
|                                                              |
|o5 = image | e_1e_2 0         0         0         |           |
|           | 0      e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 |           |
|                                                              |
|                             2                                |
|o5 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i6 : isStronglyStableModule M                                 |
|                                                              |
|o6 = false                                                    |
+--------------------------------------------------------------+
|i7 : Mss=stronglyStableModule M                               |
|                                                              |
|o7 = image | e_1e_2 e_1e_3e_4 0         0         0         | |
|           | 0      0         e_1e_3e_4 e_1e_2e_4 e_1e_2e_3 | |
|                                                              |
|                             2                                |
|o7 : E-module, submodule of E                                 |
+--------------------------------------------------------------+
|i8 : isStronglyStableModule Mss                               |
|                                                              |
|o8 = true                                                     |
+--------------------------------------------------------------+

See also
========

  * isStronglyStableModule -- whether a monomial
    module over an exterior algebra is strongly stable
  * isAlmostStronglyStableModule, --
    whether a monomial module over an exterior algebra is almost strongly
    stable

Ways to use stronglyStableModule:
=================================

  * "stronglyStableModule(Module)"

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

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

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

The source of this document is in ExteriorModules.m2:844:0.