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

OIGroebnerBases -- OI-modules over Noetherian polynomial OI-algebras
********************************************************************

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

OIGroebnerBases is a package for Gröbner bases, syzygies and free resolutions
for submodules of free OI-modules over Noetherian polynomial OI-algebras. For
an introduction to the theory of OI-modules, see [3].

Given a Noetherian polynomial OI-algebra $\mathbf{P} :=
(\mathbf{X}^{\text{OI},1})^{\otimes c}$ for some integer $c > 0$, one can
consider free OI-modules $\mathbf{F} := \bigoplus_{i=1}^s\mathbf{F}^{\text{OI},
d_i}$ over $\mathbf{P}$ for integers $d_i\geq 0$.

Gröbner bases for submodules of $\mathbf{F}$ were introduced in [3]. Free
resolutions and homological aspects of submodules have been studied in [2,3].
Using the methods of [1], Gröbner bases, syzygy modules, and free resolutions
for submodules can be computed with oiGB, oiSyz, and
oiRes, respectively.

References:

[1] M. Morrow and U. Nagel, Computing Gröbner Bases and Free Resolutions of
OI-Modules, Preprint, arXiv:2303.06725, 2023.

[2] N. Fieldsteel and U. Nagel, Minimal and cellular free resolutions over
polynomial OI-algebras, Preprint, arXiv:2105.08603, 2021.

[3] U. Nagel and T. Römer, FI- and OI-modules with varying coefficients, J.
Algebra 535 (2019), 286-322.

Author
======

  * Michael Morrow (see https://michaelmorrow.me ) <michaelhmorrow98@gmail.com>

Version
=======

This documentation describes version 1.0.0 of OIGroebnerBases.

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

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

Exports
=======

  * Types
      * FreeOIModule -- the class of all free OI-modules
        over a polynomial OI-algebra
      * FreeOIModuleMap -- the class of all maps
        between free OI-modules
      * ModuleInWidth -- the class of all modules that
        appear as a component of a free OI-module
      * OIResolution -- the class of all resolutions of
        submodules of free OI-modules
      * PolynomialOIAlgebra -- the class of all
        Noetherian polynomial OI-algebras over a field
      * VectorInWidth -- the class of all elements of a
        free OI-module
  * Functions and commands
      * describeFull -- describe an OI-resolution and the
        maps
      * getBasisElements -- get the basis elements of
        a free OI-module
      * getFreeOIModule -- get the free OI-module of an
        element
      * getRank -- get the rank of a free OI-module
      * getSchreyerMap -- get the Schreyer map of a free
        OI-module if it exists
      * getWidth -- get the width of an element of a free
        OI-module
      * installGeneratorsInWidth -- install
        the generators for a component of a free OI-module in a specified width
      * isComplex -- verify that an OI-resolution is a
        complex
      * isOIGB -- check if a list of elements of a free
        OI-module forms a Gröbner basis
      * isZero -- check if a free OI-module is zero
      * makeFreeOIModule -- make a FreeOIModule object
      * makePolynomialOIAlgebra -- make a
        PolynomialOIAlgebra object
      * minimizeOIGB -- minimize an OI-Gröbner basis
      * oiGB -- compute a Gröbner basis for a submodule of a free
        OI-module
      * oiOrbit -- compute the n-orbit of a list of elements of
        a free OI-module
      * oiRes -- compute an OI-resolution
      * oiSyz -- compute a Gröbner basis for the syzygy module of
        a submodule of a free OI-module
      * ranks -- display the ranks of an OI-resolution
      * reduceOIGB -- reduce an OI-Gröbner basis
      * restrictedRanks -- display the ranks of an
        OI-resolution restricted to a given width
  * Methods
      * - VectorInWidth -- multiply an element of a
        free OI-module by -1
      * degree(VectorInWidth) -- get the
        degree of an element of a free OI-module
      * describe(FreeOIModuleMap), --
        display a free OI-module map
      * describe(OIResolution) -- describe
        an OI-resolution
      * "describeFull(OIResolution)" -- see describeFull,
        -- describe an OI-resolution and the maps
      * FreeOIModule _ ZZ -- get the width n
        component of a free OI-module
      * FreeOIModuleMap VectorInWidth, --
        apply a free OI-module map to an element
      * "getBasisElements(FreeOIModule)" -- see getBasisElements,
        -- get the basis elements of a free OI-module
      * "getFreeOIModule(VectorInWidth)" -- see getFreeOIModule,
        -- get the free OI-module of an element
      * "getRank(FreeOIModule)" -- see getRank, -- get the rank
        of a free OI-module
      * "getSchreyerMap(FreeOIModule)" -- see getSchreyerMap,
        -- get the Schreyer map of a free OI-module if it
        exists
      * "getWidth(VectorInWidth)" -- see getWidth, -- get the
        width of an element of a free OI-module
      * image(FreeOIModuleMap) -- get the
        basis element images of a free OI-module map
      * "installGeneratorsInWidth(FreeOIModule,ZZ)" -- see
        installGeneratorsInWidth, -- install the
        generators for a component of a free OI-module in a specified width
      * "isComplex(OIResolution)" -- see isComplex, -- verify
        that an OI-resolution is a complex
      * isHomogeneous(FreeOIModuleMap)
        -- checks if a free OI-module map
        is homogeneous
      * isHomogeneous(VectorInWidth),
        -- check if an element of a free OI-module is homogeneous
      * "isOIGB(List)" -- see isOIGB, -- check if a list of
        elements of a free OI-module forms a Gröbner basis
      * "isZero(FreeOIModule)" -- see isZero, -- check if a free
        OI-module is zero
      * isZero(FreeOIModuleMap) -- check if
        a free OI-module map is zero
      * isZero(VectorInWidth) -- check if an
        element of a free OI-module is zero
      * leadCoefficient(VectorInWidth)
        -- get the lead coefficient of an
        element of a free OI-module
      * leadMonomial(VectorInWidth), --
        get the lead monomial of an element of a free OI-module
      * leadTerm(VectorInWidth) -- get the
        lead term of an element of a free OI-module
      * "makeFreeOIModule(Symbol,List,PolynomialOIAlgebra)" -- see
        makeFreeOIModule, -- make a FreeOIModule object
      * "makePolynomialOIAlgebra(ZZ,Symbol,Ring)" -- see
        makePolynomialOIAlgebra, -- make a
        PolynomialOIAlgebra object
      * "minimizeOIGB(List)" -- see minimizeOIGB, --
        minimize an OI-Gröbner basis
      * net(FreeOIModule) -- display a free
        OI-module
      * net(FreeOIModuleMap) -- display a free
        OI-module map source and target
      * net(ModuleInWidth) -- display a
        component of a free OI-module in a specified width
      * net(OIResolution) -- display an
        OI-resolution
      * net(PolynomialOIAlgebra), --
        display a polynomial OI-algebra
      * net(VectorInWidth) -- display an element
        of a free OI-module
      * Number * VectorInWidth -- multiply an
        element of a free OI-module by a number
      * "oiGB(List)" -- see oiGB, -- compute a Gröbner basis for a
        submodule of a free OI-module
      * "oiOrbit(List,ZZ)" -- see oiOrbit, -- compute the
        n-orbit of a list of elements of a free OI-module
      * "oiRes(List,ZZ)" -- see oiRes, -- compute an OI-resolution
      * OIResolution _ ZZ -- get a module of an
        OI-resolution is specified homological degree
      * "oiSyz(List,Symbol)" -- see oiSyz, -- compute a Gröbner
        basis for the syzygy module of a submodule of a free OI-module
      * PolynomialOIAlgebra _ ZZ -- get the
        $K$-algebra in a specified width of a polynomial OI-algebra
      * "ranks(OIResolution)" -- see ranks, -- display the ranks
        of an OI-resolution
      * "reduceOIGB(List)" -- see reduceOIGB, -- reduce an
        OI-Gröbner basis
      * "restrictedRanks(OIResolution,ZZ)" -- see restrictedRanks,
        -- display the ranks of an OI-resolution restricted to
        a given width
      * RingElement * VectorInWidth, --
        multiply an element of a free OI-module by a ring element
      * terms(VectorInWidth) -- get the terms
        of an element of a free OI-module
      * toString(FreeOIModule) -- display a
        free OI-module in condensed form
      * toString(PolynomialOIAlgebra),
        -- display a polynomial OI-algebra in condensed form
      * use(ModuleInWidth) -- use a component of
        a free OI-module
      * VectorInWidth + VectorInWidth, --
        add two elements of a free OI-module
      * VectorInWidth - VectorInWidth, --
        subtract an element of a free OI-module from another
  * Symbols
      * ColDownRowDown -- column down row down variable
        order
      * ColDownRowUp -- column down row up variable order
      * ColUpRowDown -- column up row down variable order
      * ColUpRowUp -- column up row up variable order
      * DegreeShifts -- grading shifts for free OI-modules
      * OIMonomialOrder -- monomial order option for
        free OI-modules
      * RowDownColDown -- row down column down variable
        order
      * RowDownColUp -- row up column up variable order
      * RowUpColDown -- row up column down variable order
      * RowUpColUp -- row up column up variable order
      * TopNonminimal -- option for minimizing the top
        Gröbner basis of an OI-resolution
      * VariableOrder -- variable ordering for polynomial
        OI-algebras

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

The object OIGroebnerBases, is a package (Macaulay2Doc).

Polynomial OI-algebras

Free OI-modules

OI-Gröbner bases

OI-syzygies

OI-resolutions

PolynomialOIAlgebra -- the class of all Noetherian polynomial OI-algebras over a field
**************************************************************************************

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

This type implements OI-algebras of the form
$(\mathbf{X}^{\text{OI},1})^{\otimes c}$ for some integer $c>0$. To make a
PolynomialOIAlgebra object, use makePolynomialOIAlgebra.
Each PolynomialOIAlgebra object is equipped with a
variable order; see VariableOrder.

+-------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ, VariableOrder => RowDownColUp)|
|                                                                         |
|o1 = Number of variable rows: 2                                          |
|     Variable symbol: x                                                  |
|     Base field: QQ                                                      |
|     Variable order: RowDownColUp                                        |
|                                                                         |
|o1 : PolynomialOIAlgebra                                                 |
+-------------------------------------------------------------------------+

Functions and methods returning an object of class PolynomialOIAlgebra:
=======================================================================

  * makePolynomialOIAlgebra -- make a
    PolynomialOIAlgebra object

Methods that use an object of class PolynomialOIAlgebra:
========================================================

  * "makeFreeOIModule(Symbol,List,PolynomialOIAlgebra)" -- see
    makeFreeOIModule, -- make a FreeOIModule object
  * net(PolynomialOIAlgebra) -- display a
    polynomial OI-algebra
  * PolynomialOIAlgebra _ ZZ -- get the
    $K$-algebra in a specified width of a polynomial OI-algebra
  * toString(PolynomialOIAlgebra), --
    display a polynomial OI-algebra in condensed form

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

The object PolynomialOIAlgebra, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

makePolynomialOIAlgebra -- make a PolynomialOIAlgebra object
************************************************************

Synopsis
========

  * Usage:
        makePolynomialOIAlgebra(c,x,K)
  * Inputs:
      * c, an integer (Macaulay2Doc),
      * x, a symbol (Macaulay2Doc),
      * K, a ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * VariableOrder => ..., default value RowUpColUp
  * Outputs:
      * an instance of the type PolynomialOIAlgebra,

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

Makes a polynomial OI-algebra over the field K with c rows of variables in the
symbol x. The VariableOrder, option is used to specify the
ordering of the variables.

+-------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(1, x, QQ)                               |
|                                                                         |
|o1 = Number of variable rows: 1                                          |
|     Variable symbol: x                                                  |
|     Base field: QQ                                                      |
|     Variable order: RowUpColUp                                          |
|                                                                         |
|o1 : PolynomialOIAlgebra                                                 |
+-------------------------------------------------------------------------+
|i2 : Q = makePolynomialOIAlgebra(2, y, QQ, VariableOrder => RowDownColUp)|
|                                                                         |
|o2 = Number of variable rows: 2                                          |
|     Variable symbol: y                                                  |
|     Base field: QQ                                                      |
|     Variable order: RowDownColUp                                        |
|                                                                         |
|o2 : PolynomialOIAlgebra                                                 |
+-------------------------------------------------------------------------+

Ways to use makePolynomialOIAlgebra:
====================================

  * "makePolynomialOIAlgebra(ZZ,Symbol,Ring)"

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

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

VariableOrder -- variable ordering for polynomial OI-algebras
*************************************************************

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

Used as an optional argument in makePolynomialOIAlgebra,
to specify an ordering on the variables of a
polynomial OI-algebra.

Permissible values:

  * VariableOrder => "ColUpRowUp"
  * VariableOrder => "ColUpRowDown"
  * VariableOrder => "ColDownRowUp"
  * VariableOrder => "ColDownRowDown"
  * VariableOrder => "RowUpColUp"
  * VariableOrder => "RowUpColDown"
  * VariableOrder => "RowDownColUp"
  * VariableOrder => "RowDownColDown"
+-------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ, VariableOrder => RowDownColUp)|
|                                                                         |
|o1 = Number of variable rows: 2                                          |
|     Variable symbol: x                                                  |
|     Base field: QQ                                                      |
|     Variable order: RowDownColUp                                        |
|                                                                         |
|o1 : PolynomialOIAlgebra                                                 |
+-------------------------------------------------------------------------+

Functions with optional argument named VariableOrder:
=====================================================

  * "makePolynomialOIAlgebra(...,VariableOrder=>...)" -- see
    makePolynomialOIAlgebra, -- make a
    PolynomialOIAlgebra object

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

The object VariableOrder, is a symbol (Macaulay2Doc).

ColUpRowUp -- column up row up variable order
*********************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $j'<j$ or $j'=j$ and $i'<i$.

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

The object ColUpRowUp, is a symbol (Macaulay2Doc).

ColUpRowDown -- column up row down variable order
*************************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $j'<j$ or $j'=j$ and $i'>i$.

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

The object ColUpRowDown, is a symbol (Macaulay2Doc).

ColDownRowUp -- column down row up variable order
*************************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $j'>j$ or $j'=j$ and $i'<i$.

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

The object ColDownRowUp, is a symbol (Macaulay2Doc).

ColDownRowDown -- column down row down variable order
*****************************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $j'>j$ or $j'=j$ and $i'>i$.

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

The object ColDownRowDown, is a symbol (Macaulay2Doc).

RowUpColUp -- row up column up variable order
*********************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $i'<i$ or $i'=i$ and $j'<j$.

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

The object RowUpColUp, is a symbol (Macaulay2Doc).

RowUpColDown -- row up column down variable order
*************************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $i'<i$ or $i'=i$ and $j'>j$.

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

The object RowUpColDown, is a symbol (Macaulay2Doc).

RowDownColUp -- row up column up variable order
***********************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $i'>i$ or $i'=i$ and $j'<j$.

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

The object RowDownColUp, is a symbol (Macaulay2Doc).

RowDownColDown -- row down column down variable order
*****************************************************

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

Orders the variables of a polynomial OI-algebra according to $x_{i',j'} <
x_{i,j}$ if $i'>i$ or $i'=i$ and $j'>j$.

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

The object RowDownColDown, is a symbol (Macaulay2Doc).

net(PolynomialOIAlgebra) -- display a polynomial OI-algebra
***********************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net P
  * Inputs:
      * P, an instance of the type PolynomialOIAlgebra,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the base field, number of variable rows, variable symbol, and variable
order of a PolynomialOIAlgebra, object.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : net P                                 |
|                                           |
|o2 = Number of variable rows: 2            |
|     Variable symbol: x                    |
|     Base field: QQ                        |
|     Variable order: RowUpColUp            |
+-------------------------------------------+

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

  * net(PolynomialOIAlgebra) -- display a
    polynomial OI-algebra

toString(PolynomialOIAlgebra) -- display a polynomial OI-algebra in condensed form
**********************************************************************************

Synopsis
========

  * Function: toString (Macaulay2Doc),
  * Usage:
        toString P
  * Inputs:
      * P, an instance of the type PolynomialOIAlgebra,
  * Outputs:
      * a string (Macaulay2Doc),

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

Displays the base field, number of variable rows, variable symbol, and variable
order of a PolynomialOIAlgebra, object as a string.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : toString P                            |
|                                           |
|o2 = (2, x, QQ, RowUpColUp)                |
+-------------------------------------------+

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

  * toString(PolynomialOIAlgebra), --
    display a polynomial OI-algebra in condensed form

PolynomialOIAlgebra _ ZZ -- get the $K$-algebra in a specified width of a polynomial OI-algebra
***********************************************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        P_n
  * Inputs:
      * P, an instance of the type PolynomialOIAlgebra,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

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

Returns the $K$-algebra in width n of a polynomial OI-algebra.

+-------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, y, QQ);            |
+-------------------------------------------------------+
|i2 : P_4                                               |
|                                                       |
|o2 = QQ[y   , y   , y   , y   , y   , y   , y   , y   ]|
|         2,4   2,3   2,2   2,1   1,4   1,3   1,2   1,1 |
|                                                       |
|o2 : PolynomialRing                                    |
+-------------------------------------------------------+

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

  * PolynomialOIAlgebra _ ZZ -- get the
    $K$-algebra in a specified width of a polynomial OI-algebra

FreeOIModule -- the class of all free OI-modules over a polynomial OI-algebra
*****************************************************************************

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

This type implements free OI-modules over polynomial OI-algebras. To make a
FreeOIModule object, use makeFreeOIModule. To get the
basis elements and rank of a free OI-module, use getBasisElements,
and getRank, respectively. To install the
generators of a component of a free OI-module in a specified width, use
installGeneratorsInWidth.

Each FreeOIModule object comes equipped with either the Lex (Macaulay2Doc),
monomial order induced by the monomial order on its
underlying polynomial OI-algebra, or the Schreyer monomial order induced by
another free OI-module; see makeFreeOIModule, and
OIMonomialOrder.

+--------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);       |
+--------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P)            |
|                                                  |
|o2 = Basis symbol: e                              |
|     Basis element widths: {1, 2}                 |
|     Degree shifts: {0, 0}                        |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)|
|     Monomial order: Lex                          |
|                                                  |
|o2 : FreeOIModule                                 |
+--------------------------------------------------+

Functions and methods returning an object of class FreeOIModule:
================================================================

  * getFreeOIModule -- get the free OI-module of an
    element
  * makeFreeOIModule -- make a FreeOIModule object

Methods that use an object of class FreeOIModule:
=================================================

  * FreeOIModule _ ZZ -- get the width n component
    of a free OI-module
  * "getBasisElements(FreeOIModule)" -- see getBasisElements,
    -- get the basis elements of a free OI-module
  * "getRank(FreeOIModule)" -- see getRank, -- get the rank of a
    free OI-module
  * "getSchreyerMap(FreeOIModule)" -- see getSchreyerMap,
    -- get the Schreyer map of a free OI-module if it exists
  * "installGeneratorsInWidth(FreeOIModule,ZZ)" -- see
    installGeneratorsInWidth, -- install the
    generators for a component of a free OI-module in a specified width
  * "isZero(FreeOIModule)" -- see isZero, -- check if a free
    OI-module is zero
  * net(FreeOIModule) -- display a free OI-module
  * toString(FreeOIModule) -- display a free
    OI-module in condensed form

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

The object FreeOIModule, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

FreeOIModuleMap -- the class of all maps between free OI-modules
****************************************************************

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

This type implements morphisms between free OI-modules. Given free OI-modules
$\mathbf{F}$ and $\mathbf{G}$ over an OI-algebra $\mathbf{P}$, a
$\mathbf{P}$-linear map $\varphi:\mathbf{F}\to\mathbf{G}$ is determined by the
images of the basis elements of $\mathbf{F}$.

To evaluate $\varphi$ on an element of $\mathbf{F}$, use FreeOIModuleMap VectorInWidth.

One obtains FreeOIModuleMap objects through the use of oiRes, as
in the below example.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);          |
+-----------------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2)                                                       |
|                                                                             |
|o5 = 0: (e0, {3}, {-2})                                                      |
|     1: (e1, {5, 5}, {-4, -3})                                               |
|     2: (e2, {6, 6, 6, 6, 6, 6, 6, 6, 6}, {-4, -5, -5, -5, -3, -2, -4, -4,   |
|                                                                             |
|o5 : OIResolution                                                            |
|-----------------------------------------------------------------------------|
|-3})                                                                         |
+-----------------------------------------------------------------------------+
|i6 : phi = C.dd_1                                                            |
|                                                                             |
|o6 = Source: (e1, {5, 5}, {-4, -3}) Target: (e0, {3}, {-2})                  |
|                                                                             |
|o6 : FreeOIModuleMap                                                         |
+-----------------------------------------------------------------------------+
|i7 : G = getBasisElements C_1                                                |
|                                                                             |
|o7 = {1e1                   , 1e1                   }                        |
|         5,{1, 2, 3, 4, 5},1     5,{1, 2, 3, 4, 5},2                         |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : phi G#0                                                                 |
|                                                                             |
|o8 = x   x   e0              - x   x   e0              -                     |
|      2,3 1,1  5,{2, 4, 5},1    2,4 1,1  5,{2, 3, 5},1                       |
|                                                                             |
|                                                                             |
|o8 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   ,                     |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3                      |
|-----------------------------------------------------------------------------|
|x   x   e0              + x   x   e0                                         |
| 2,3 1,2  5,{1, 4, 5},1    2,4 1,2  5,{1, 3, 5},1                            |
|                                                                             |
|            10                                                               |
|x   , x   ])   in width 5, degrees {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}            |
| 1,2   1,1                                                                   |
+-----------------------------------------------------------------------------+
|i9 : phi G#1                                                                 |
|                                                                             |
|o9 = -x   e0              + x   e0              + x   e0              -      |
|       2,2  5,{1, 3, 5},1    2,2  5,{1, 3, 4},1    2,3  5,{1, 2, 5},1        |
|                                                                             |
|                                                                     10      |
|o9 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   , x   , x   ])        |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3   1,2   1,1          |
|-----------------------------------------------------------------------------|
|x   e0                                                                       |
| 2,3  5,{1, 2, 4},1                                                          |
|                                                                             |
|                                                                             |
|in width 5, degrees {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}                           |
+-----------------------------------------------------------------------------+

Functions and methods returning an object of class FreeOIModuleMap:
===================================================================

  * getSchreyerMap -- get the Schreyer map of a free
    OI-module if it exists

Methods that use an object of class FreeOIModuleMap:
====================================================

  * describe(FreeOIModuleMap) -- display
    a free OI-module map
  * FreeOIModuleMap VectorInWidth, --
    apply a free OI-module map to an element
  * image(FreeOIModuleMap) -- get the basis
    element images of a free OI-module map
  * isHomogeneous(FreeOIModuleMap),
    -- checks if a free OI-module map is homogeneous
  * isZero(FreeOIModuleMap) -- check if a
    free OI-module map is zero
  * net(FreeOIModuleMap) -- display a free
    OI-module map source and target

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

The object FreeOIModuleMap, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

ModuleInWidth -- the class of all modules that appear as a component of a free OI-module
****************************************************************************************

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

The width $n$ component of a free OI-module is implemented as a ModuleInWidth
object. To obtain a ModuleInWidth object, one restricts a given free OI-module
to a specified width using FreeOIModule _ ZZ, as
seen in the example below.

+---------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);  |
+---------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);      |
+---------------------------------------------+
|i3 : F_2                                     |
|                                             |
|                                 3           |
|o3 = (QQ[x   , x   , x   , x   ])  in width 2|
|          2,2   2,1   1,2   1,1              |
|                                             |
|o3 : ModuleInWidth                           |
+---------------------------------------------+

Methods that use an object of class ModuleInWidth:
==================================================

  * net(ModuleInWidth) -- display a component of
    a free OI-module in a specified width
  * use(ModuleInWidth) -- use a component of a
    free OI-module

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

The object ModuleInWidth, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

VectorInWidth -- the class of all elements of a free OI-module
**************************************************************

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

An element of a free OI-module $\mathbf{F}$ is defined to be an element of
$\mathbf{F}_n$ for some integer $n\geq0$. Such an element is implemented as a
VectorInWidth object. One typically makes VectorInWidth objects by defining a
FreeOIModule, object, calling
installGeneratorsInWidth, and then manipulating the
generators; see below for an example.

+------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);     |
+------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);         |
+------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);            |
+------------------------------------------------+
|i4 : b = x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)|
|                                                |
|o4 = x   e        + x   e                       |
|      1,1 2,{1},1    2,1 2,{1},2                |
|                                                |
|                                 4              |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2   |
|          2,2   2,1   1,2   1,1                 |
+------------------------------------------------+
|i5 : instance(b, VectorInWidth)                 |
|                                                |
|o5 = true                                       |
+------------------------------------------------+

Methods that use an object of class VectorInWidth:
==================================================

  * - VectorInWidth -- multiply an element of a free
    OI-module by -1
  * degree(VectorInWidth) -- get the degree
    of an element of a free OI-module
  * FreeOIModuleMap VectorInWidth, --
    apply a free OI-module map to an element
  * "getFreeOIModule(VectorInWidth)" -- see getFreeOIModule,
    -- get the free OI-module of an element
  * "getWidth(VectorInWidth)" -- see getWidth, -- get the width
    of an element of a free OI-module
  * isHomogeneous(VectorInWidth), --
    check if an element of a free OI-module is homogeneous
  * isZero(VectorInWidth) -- check if an
    element of a free OI-module is zero
  * leadCoefficient(VectorInWidth),
    -- get the lead coefficient of an element of a free OI-module
  * leadMonomial(VectorInWidth) -- get
    the lead monomial of an element of a free OI-module
  * leadTerm(VectorInWidth) -- get the lead
    term of an element of a free OI-module
  * net(VectorInWidth) -- display an element of
    a free OI-module
  * Number * VectorInWidth -- multiply an
    element of a free OI-module by a number
  * RingElement * VectorInWidth, --
    multiply an element of a free OI-module by a ring element
  * terms(VectorInWidth) -- get the terms of
    an element of a free OI-module
  * VectorInWidth + VectorInWidth -- add
    two elements of a free OI-module
  * VectorInWidth - VectorInWidth, --
    subtract an element of a free OI-module from another

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

The object VectorInWidth, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

makeFreeOIModule -- make a FreeOIModule object
**********************************************

Synopsis
========

  * Usage:
        makeFreeOIModule(e,L,P)
  * Inputs:
      * e, a symbol (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
      * P, an instance of the type PolynomialOIAlgebra,
  * Optional inputs (Macaulay2Doc),:
      * DegreeShifts => ..., default value null
      * OIMonomialOrder => ..., default value Lex
  * Outputs:
      * an instance of the type FreeOIModule,

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

Makes a free OI-module of the form $\bigoplus_{i=1}^s\mathbf{F}^{\text{OI},
d_i}$ over the PolynomialOIAlgebra, object P with
$L=\{d_1,\ldots,d_s\}$ and basis symbol e.

The DegreeShifts, option is used to specify a shift of
grading. This option must be set to either null for no shifts, or a list of
integers describing the desired shifts.

The OIMonomialOrder, option must be set to either
Lex (Macaulay2Doc), for the lexicographic order, or a list of elements of
some free OI-module for the Schreyer order. See below for examples.

Example 1: Lex
==============

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P, DegreeShifts => {3,2,1})|
|                                                                 |
|o2 = Basis symbol: e                                             |
|     Basis element widths: {1, 1, 2}                             |
|     Degree shifts: {3, 2, 1}                                    |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)               |
|     Monomial order: Lex                                         |
|                                                                 |
|o2 : FreeOIModule                                                |
+-----------------------------------------------------------------+

Example 2: Schreyer
===================

+-----------------------------------------------------------------------------+
|i3 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i5 : b = x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2);                            |
+-----------------------------------------------------------------------------+
|i6 : G = makeFreeOIModule(d, {2}, P, DegreeShifts => {-degree b},            |
|                                                                             |
|o6 = Basis symbol: d                                                         |
|     Basis element widths: {2}                                               |
|     Degree shifts: {-1}                                                     |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)                           |
|     Monomial order: Schreyer                                                |
|                                                                             |
|o6 : FreeOIModule                                                            |
|-----------------------------------------------------------------------------|
|OIMonomialOrder => {b})                                                      |
+-----------------------------------------------------------------------------+

Ways to use makeFreeOIModule:
=============================

  * "makeFreeOIModule(Symbol,List,PolynomialOIAlgebra)"

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

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

DegreeShifts -- grading shifts for free OI-modules
**************************************************

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

Used as an optional argument in makeFreeOIModule, to
specify shifts of grading.

Permissible values:

  * DegreeShifts => null for no shift of grading
  * DegreeShifts => "List" for a shift of grading indicated by a list of
    integers

Example 1: no shifts
====================

The free OI-module $\mathbf{F}^{\text{OI},1}\oplus\mathbf{F}^{\text{OI},2}$ has
its basis elements in degree zero.

+--------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(1, x, QQ);       |
+--------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P)            |
|                                                  |
|o2 = Basis symbol: e                              |
|     Basis element widths: {1, 2}                 |
|     Degree shifts: {0, 0}                        |
|     Polynomial OI-algebra: (1, x, QQ, RowUpColUp)|
|     Monomial order: Lex                          |
|                                                  |
|o2 : FreeOIModule                                 |
+--------------------------------------------------+
|i3 : apply(getBasisElements F, degree)            |
|                                                  |
|o3 = {0, 0}                                       |
|                                                  |
|o3 : List                                         |
+--------------------------------------------------+

Example 2: nontrivial shifts
============================

The free OI-module $\mathbf{F}^{\text{OI},1}(-3)\oplus\mathbf{F}^{\text{OI},2
}(-4)$ has its basis elements in degrees $3$ and $4$.

+---------------------------------------------------------------+
|i4 : F = makeFreeOIModule(e, {1,2}, P, DegreeShifts => {-3,-4})|
|                                                               |
|o4 = Basis symbol: e                                           |
|     Basis element widths: {1, 2}                              |
|     Degree shifts: {-3, -4}                                   |
|     Polynomial OI-algebra: (1, x, QQ, RowUpColUp)             |
|     Monomial order: Lex                                       |
|                                                               |
|o4 : FreeOIModule                                              |
+---------------------------------------------------------------+
|i5 : apply(getBasisElements F, degree)                         |
|                                                               |
|o5 = {3, 4}                                                    |
|                                                               |
|o5 : List                                                      |
+---------------------------------------------------------------+

Functions with optional argument named DegreeShifts:
====================================================

  * "makeFreeOIModule(...,DegreeShifts=>...)" -- see makeFreeOIModule,
    -- make a FreeOIModule object

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

The object DegreeShifts, is a symbol (Macaulay2Doc).

OIMonomialOrder -- monomial order option for free OI-modules
************************************************************

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

Used as an optional argument in makeFreeOIModule, to
specify the desired monomial order.

Permissible values:

  * OIMonomialOrder => "Lex" for the lexicographic order induced by the
    monomial order of the underlying polynomial OI-algebra; see [1, Example
    3.2]
  * OIMonomialOrder => "List" for the Schreyer order induced by a list of
    elements of a free OI-module; see [1, Definition 4.2]

References:

[1] M. Morrow and U. Nagel, Computing Gröbner Bases and Free Resolutions of
OI-Modules, Preprint, arXiv:2303.06725, 2023.

Functions with optional argument named OIMonomialOrder:
=======================================================

  * "makeFreeOIModule(...,OIMonomialOrder=>...)" -- see makeFreeOIModule,
    -- make a FreeOIModule object

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

The object OIMonomialOrder, is a symbol (Macaulay2Doc).

installGeneratorsInWidth -- install the generators for a component of a free OI-module in a specified width
***********************************************************************************************************

Synopsis
========

  * Usage:
        installGeneratorsInWidth(F, n)
  * Inputs:
      * F, an instance of the type FreeOIModule,
      * n, an integer (Macaulay2Doc),

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

This method assigns the generators of the width n component of F to the
appropriate IndexedVariable (Macaulay2Doc), corresponding
to the basis symbol of F.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : e_(2,{1},1)                                                             |
|                                                                             |
|o4 = 1e                                                                      |
|       2,{1},1                                                               |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i5 : e_(2,{1},2)                                                             |
|                                                                             |
|o5 = 1e                                                                      |
|       2,{1},2                                                               |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i6 : e_(2,{2},1)                                                             |
|                                                                             |
|o6 = 1e                                                                      |
|       2,{2},1                                                               |
|                                                                             |
|                                 4                                           |
|o6 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i7 : e_(2,{2},2)                                                             |
|                                                                             |
|o7 = 1e                                                                      |
|       2,{2},2                                                               |
|                                                                             |
|                                 4                                           |
|o7 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i8 : x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e_(2|
|                                                                             |
|o8 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
|                                                                             |
|                                 4                                           |
|o8 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|,{2},2)                                                                      |
+-----------------------------------------------------------------------------+

Ways to use installGeneratorsInWidth:
=====================================

  * "installGeneratorsInWidth(FreeOIModule,ZZ)"

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

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

isZero -- check if a free OI-module is zero
*******************************************

Synopsis
========

  * Usage:
        isZero F
  * Inputs:
      * F, an instance of the type FreeOIModule,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if a free OI-module is the zero module.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);    |
+-------------------------------------------+
|i3 : G = makeFreeOIModule(d, {}, P);       |
+-------------------------------------------+
|i4 : isZero F                              |
|                                           |
|o4 = false                                 |
+-------------------------------------------+
|i5 : isZero G                              |
|                                           |
|o5 = true                                  |
+-------------------------------------------+

Ways to use isZero:
===================

  * "isZero(FreeOIModule)"
  * isZero(FreeOIModuleMap) -- check if a
    free OI-module map is zero
  * isZero(VectorInWidth) -- check if an
    element of a free OI-module is zero

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

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

getBasisElements -- get the basis elements of a free OI-module
**************************************************************

Synopsis
========

  * Usage:
        getBasisElements F
  * Inputs:
      * F, an instance of the type FreeOIModule,
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the basis elements of a free OI-module.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);    |
+-------------------------------------------+
|i3 : getBasisElements F                    |
|                                           |
|o3 = {1e       , 1e       }                |
|        1,{1},1    1,{1},2                 |
|                                           |
|o3 : List                                  |
+-------------------------------------------+

Ways to use getBasisElements:
=============================

  * "getBasisElements(FreeOIModule)"

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

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

getFreeOIModule -- get the free OI-module of an element
*******************************************************

Synopsis
========

  * Usage:
        getFreeOIModule f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type FreeOIModule,

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

Returns the free OI-module in which the element f lives.

+----------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                           |
+----------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                             |
+----------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 4);                                  |
+----------------------------------------------------------------------+
|i4 : f = x_(2,4)*e_(4,{3},1)+x_(1,3)^2*e_(4,{2,4},3)                  |
|                                                                      |
|                     2                                                |
|o4 = x   e        + x   e                                             |
|      2,4 4,{3},1    1,3 4,{2, 4},3                                   |
|                                                                      |
|                                                         14           |
|o4 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   ])   in width 4|
|          2,4   2,3   2,2   2,1   1,4   1,3   1,2   1,1               |
+----------------------------------------------------------------------+
|i5 : getFreeOIModule f                                                |
|                                                                      |
|o5 = Basis symbol: e                                                  |
|     Basis element widths: {1, 1, 2}                                  |
|     Degree shifts: {0, 0, 0}                                         |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)                    |
|     Monomial order: Lex                                              |
|                                                                      |
|o5 : FreeOIModule                                                     |
+----------------------------------------------------------------------+

Ways to use getFreeOIModule:
============================

  * "getFreeOIModule(VectorInWidth)"

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

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

getSchreyerMap -- get the Schreyer map of a free OI-module if it exists
***********************************************************************

Synopsis
========

  * Usage:
        getSchreyerMap H
  * Inputs:
      * H, an instance of the type FreeOIModule,
  * Outputs:
      * an instance of the type FreeOIModuleMap,

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

Let $G'$ be a non-empty Gröbner basis for the syzygy module of a finitely
generated submodule $\mathbf{M}$ of a free OI-module $\mathbf{F}$ computed
using oiSyz. Let H be the free OI-module obtained by applying
getFreeOIModule, to any element of $G'$. This method
returns the canonical surjective map from H to $\mathbf{M}$.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);            |
+-----------------------------------------------------------------------------+
|i5 : G = oiGB {b}                                                            |
|                                                                             |
|o5 = {x   x   e        + x   x   e       , x   x   x   e        -            |
|       1,2 1,1 2,{2},1    2,2 2,1 2,{1},2   2,3 2,2 1,1 3,{2},2              |
|     ------------------------------------------------------------------------|
|     x   x   x   e       }                                                   |
|      2,3 2,1 1,2 3,{1},2                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : G' = oiSyz(G, d)                                                        |
|                                                                             |
|o6 = {x   d           - x   d           + 1d             , x   d             |
|       1,2 3,{1, 3},1    1,1 3,{2, 3},1     3,{1, 2, 3},2   2,4 4,{1, 2, 3},2|
|     ------------------------------------------------------------------------|
|     - x   d             , x   d              - x   d              -         |
|        2,3 4,{1, 2, 4},2   1,2 4,{1, 3, 4},2    1,1 4,{2, 3, 4},2           |
|     ------------------------------------------------------------------------|
|     x   d             }                                                     |
|      1,3 4,{1, 2, 4},2                                                      |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : H = getFreeOIModule G'#0                                                |
|                                                                             |
|o7 = Basis symbol: d                                                         |
|     Basis element widths: {2, 3}                                            |
|     Degree shifts: {-2, -3}                                                 |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)                           |
|     Monomial order: Schreyer                                                |
|                                                                             |
|o7 : FreeOIModule                                                            |
+-----------------------------------------------------------------------------+
|i8 : getSchreyerMap H                                                        |
|                                                                             |
|o8 = Source: (d, {2, 3}, {-2, -3}) Target: (e, {1, 1}, {0, 0})               |
|                                                                             |
|o8 : FreeOIModuleMap                                                         |
+-----------------------------------------------------------------------------+

Caveat
======

If $G'$ is empty or if H does not have a Schreyer order, this method will throw
an error.

Ways to use getSchreyerMap:
===========================

  * "getSchreyerMap(FreeOIModule)"

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

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

getWidth -- get the width of an element of a free OI-module
***********************************************************

Synopsis
========

  * Usage:
        getWidth f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an integer (Macaulay2Doc),

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

Returns the width of an element of a free OI-module.

+----------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                           |
+----------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                             |
+----------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 4);                                  |
+----------------------------------------------------------------------+
|i4 : f = x_(2,4)*e_(4,{3},1)+x_(1,3)^2*e_(4,{2,4},3)                  |
|                                                                      |
|                     2                                                |
|o4 = x   e        + x   e                                             |
|      2,4 4,{3},1    1,3 4,{2, 4},3                                   |
|                                                                      |
|                                                         14           |
|o4 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   ])   in width 4|
|          2,4   2,3   2,2   2,1   1,4   1,3   1,2   1,1               |
+----------------------------------------------------------------------+
|i5 : getWidth f                                                       |
|                                                                      |
|o5 = 4                                                                |
+----------------------------------------------------------------------+

Ways to use getWidth:
=====================

  * "getWidth(VectorInWidth)"

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

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

getRank -- get the rank of a free OI-module
*******************************************

Synopsis
========

  * Usage:
        getRank F
  * Inputs:
      * F, an instance of the type FreeOIModule,
  * Outputs:
      * an integer (Macaulay2Doc),

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

Returns the rank of a free OI-module. Recall that the rank of a free OI-module
$\bigoplus_{i=1}^s\mathbf{F}^{\text{OI}, d_i}$ is defined to be $s$.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);  |
+-------------------------------------------+
|i3 : getRank F                             |
|                                           |
|o3 = 3                                     |
+-------------------------------------------+

Ways to use getRank:
====================

  * "getRank(FreeOIModule)"

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

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

oiOrbit -- compute the n-orbit of a list of elements of a free OI-module
************************************************************************

Synopsis
========

  * Usage:
        oiOrbit(L, n)
  * Inputs:
      * L, a list (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the $n$-orbit of the list L of VectorInWidth,
objects.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)                             |
|                                                                             |
|o4 = x   e        + x   e                                                    |
|      1,1 2,{1},1    2,1 2,{1},2                                             |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i5 : oiOrbit({b}, 4)                                                         |
|                                                                             |
|o5 = {x   e        + x   e       , x   e        + x   e       , x   e        |
|       1,1 4,{1},1    2,1 4,{1},2   1,2 4,{2},1    2,2 4,{2},2   1,3 4,{3},1 |
|     ------------------------------------------------------------------------|
|     + x   e       }                                                         |
|        2,3 4,{3},2                                                          |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use oiOrbit:
====================

  * "oiOrbit(List,ZZ)"

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

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

isZero(FreeOIModuleMap) -- check if a free OI-module map is zero
****************************************************************

Synopsis
========

  * Function: isZero,
  * Usage:
        isZero phi
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if a free OI-module map is the zero map.

+-------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);      |
+-------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {2}, P);            |
+-------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);             |
+-------------------------------------------------+
|i4 : b = e_(2,{1,2},1);                          |
+-------------------------------------------------+
|i5 : C = oiRes({b}, 2)                           |
|                                                 |
|o5 = 0: (e0, {2}, {0})                           |
|     1: (e1, {}, {})                             |
|     2: (e2, {}, {})                             |
|                                                 |
|o5 : OIResolution                                |
+-------------------------------------------------+
|i6 : phi0 = C.dd_0                               |
|                                                 |
|o6 = Source: (e0, {2}, {0}) Target: (e, {2}, {0})|
|                                                 |
|o6 : FreeOIModuleMap                             |
+-------------------------------------------------+
|i7 : phi1 = C.dd_1                               |
|                                                 |
|o7 = Source: (e1, {}, {}) Target: (e0, {2}, {0}) |
|                                                 |
|o7 : FreeOIModuleMap                             |
+-------------------------------------------------+
|i8 : isZero phi0                                 |
|                                                 |
|o8 = false                                       |
+-------------------------------------------------+
|i9 : isZero phi1                                 |
|                                                 |
|o9 = true                                        |
+-------------------------------------------------+

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

  * isZero(FreeOIModuleMap) -- check if a
    free OI-module map is zero

isZero(VectorInWidth) -- check if an element of a free OI-module is zero
************************************************************************

Synopsis
========

  * Function: isZero,
  * Usage:
        isZero f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if an element of a free OI-module is zero.

+------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                       |
+------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                           |
+------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                              |
+------------------------------------------------------------------+
|i4 : f = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2)|
|                                                                  |
|o4 = x   x   e        + x   x   e                                 |
|      1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                       |
|                                                                  |
|                                             6                    |
|o4 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i5 : isZero f                                                     |
|                                                                  |
|o5 = false                                                        |
+------------------------------------------------------------------+
|i6 : isZero(f-f)                                                  |
|                                                                  |
|o6 = true                                                         |
+------------------------------------------------------------------+

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

  * isZero(VectorInWidth) -- check if an
    element of a free OI-module is zero

FreeOIModuleMap VectorInWidth -- apply a free OI-module map to an element
*************************************************************************

Synopsis
========

  * Operator: SPACE (Macaulay2Doc),
  * Usage:
        phi f
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Evaluates phi at f.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);          |
+-----------------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2)                                                       |
|                                                                             |
|o5 = 0: (e0, {3}, {-2})                                                      |
|     1: (e1, {5, 5}, {-4, -3})                                               |
|     2: (e2, {6, 6, 6, 6, 6, 6, 6, 6, 6}, {-4, -5, -5, -5, -3, -2, -4, -4,   |
|                                                                             |
|o5 : OIResolution                                                            |
|-----------------------------------------------------------------------------|
|-3})                                                                         |
+-----------------------------------------------------------------------------+
|i6 : phi = C.dd_1                                                            |
|                                                                             |
|o6 = Source: (e1, {5, 5}, {-4, -3}) Target: (e0, {3}, {-2})                  |
|                                                                             |
|o6 : FreeOIModuleMap                                                         |
+-----------------------------------------------------------------------------+
|i7 : G = getBasisElements C_1                                                |
|                                                                             |
|o7 = {1e1                   , 1e1                   }                        |
|         5,{1, 2, 3, 4, 5},1     5,{1, 2, 3, 4, 5},2                         |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : phi G#0                                                                 |
|                                                                             |
|o8 = x   x   e0              - x   x   e0              -                     |
|      2,3 1,1  5,{2, 4, 5},1    2,4 1,1  5,{2, 3, 5},1                       |
|                                                                             |
|                                                                             |
|o8 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   ,                     |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3                      |
|-----------------------------------------------------------------------------|
|x   x   e0              + x   x   e0                                         |
| 2,3 1,2  5,{1, 4, 5},1    2,4 1,2  5,{1, 3, 5},1                            |
|                                                                             |
|            10                                                               |
|x   , x   ])   in width 5, degrees {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}            |
| 1,2   1,1                                                                   |
+-----------------------------------------------------------------------------+
|i9 : phi G#1                                                                 |
|                                                                             |
|o9 = -x   e0              + x   e0              + x   e0              -      |
|       2,2  5,{1, 3, 5},1    2,2  5,{1, 3, 4},1    2,3  5,{1, 2, 5},1        |
|                                                                             |
|                                                                     10      |
|o9 : (QQ[x   , x   , x   , x   , x   , x   , x   , x   , x   , x   ])        |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3   1,2   1,1          |
|-----------------------------------------------------------------------------|
|x   e0                                                                       |
| 2,3  5,{1, 2, 4},1                                                          |
|                                                                             |
|                                                                             |
|in width 5, degrees {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}                           |
+-----------------------------------------------------------------------------+

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

  * FreeOIModuleMap VectorInWidth, --
    apply a free OI-module map to an element

net(FreeOIModule) -- display a free OI-module
*********************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net F
  * Inputs:
      * F, an instance of the type FreeOIModule,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the basis symbol, basis element widths, degree shifts, underlying
polynomial OI-algebra, and monomial order of a free OI-module.

+--------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);       |
+--------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);           |
+--------------------------------------------------+
|i3 : net F                                        |
|                                                  |
|o3 = Basis symbol: e                              |
|     Basis element widths: {1, 2}                 |
|     Degree shifts: {0, 0}                        |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)|
|     Monomial order: Lex                          |
+--------------------------------------------------+

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

  * net(FreeOIModule) -- display a free OI-module

net(FreeOIModuleMap) -- display a free OI-module map source and target
**********************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net phi
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the source module and target module a free OI-module map.

+-------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                        |
+-------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                            |
+-------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                               |
+-------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);|
+-------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2);                                            |
+-------------------------------------------------------------------+
|i6 : phi = C.dd_1;                                                 |
+-------------------------------------------------------------------+
|i7 : net phi                                                       |
|                                                                   |
|o7 = Source: (e1, {5, 5}, {-4, -3}) Target: (e0, {3}, {-2})        |
+-------------------------------------------------------------------+

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

  * net(FreeOIModuleMap) -- display a free
    OI-module map source and target

net(ModuleInWidth) -- display a component of a free OI-module in a specified width
**********************************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net M
  * Inputs:
      * M, an instance of the type ModuleInWidth,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays information about a widthwise component of a free OI-module.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : net F_5                                                                 |
|                                                                             |
|                                                                     15      |
|o3 = (QQ[x   , x   , x   , x   , x   , x   , x   , x   , x   , x   ])   in   |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3   1,2   1,1          |
|     ------------------------------------------------------------------------|
|     width 5                                                                 |
+-----------------------------------------------------------------------------+

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

  * net(ModuleInWidth) -- display a component of
    a free OI-module in a specified width

net(VectorInWidth) -- display an element of a free OI-module
************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays an element of a free OI-module. Note: terms are displayed in
descending order according to the monomial order of the free OI-module.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e |
|-----------------------------------------------------------------------------|
|_(2,{2},2);                                                                  |
+-----------------------------------------------------------------------------+
|i5 : net f                                                                   |
|                                                                             |
|o5 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
+-----------------------------------------------------------------------------+

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

  * net(VectorInWidth) -- display an element of
    a free OI-module

image(FreeOIModuleMap) -- get the basis element images of a free OI-module map
******************************************************************************

Synopsis
========

  * Function: image (Macaulay2Doc),
  * Usage:
        image phi
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns a list containing the basis element images of a free OI-module map.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);          |
+-----------------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2);                                                      |
+-----------------------------------------------------------------------------+
|i6 : phi = C.dd_1;                                                           |
+-----------------------------------------------------------------------------+
|i7 : image phi                                                               |
|                                                                             |
|o7 = {x   x   e0              - x   x   e0              - x   x   e0         |
|       2,3 1,1  5,{2, 4, 5},1    2,4 1,1  5,{2, 3, 5},1    2,3 1,2  5,{1, 4, |
|     ------------------------------------------------------------------------|
|          + x   x   e0             , -x   e0              + x   e0           |
|     5},1    2,4 1,2  5,{1, 3, 5},1    2,2  5,{1, 3, 5},1    2,2  5,{1, 3,   |
|     ------------------------------------------------------------------------|
|          + x   e0              - x   e0             }                       |
|     4},1    2,3  5,{1, 2, 5},1    2,3  5,{1, 2, 4},1                        |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

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

  * image(FreeOIModuleMap) -- get the basis
    element images of a free OI-module map

toString(FreeOIModule) -- display a free OI-module in condensed form
********************************************************************

Synopsis
========

  * Function: toString (Macaulay2Doc),
  * Usage:
        toString F
  * Inputs:
      * F, an instance of the type FreeOIModule,
  * Outputs:
      * a string (Macaulay2Doc),

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

Displays the basis symbol, basis element widths, and degree shifts of a free
OI-module as a string.

+-------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);|
+-------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);    |
+-------------------------------------------+
|i3 : toString F                            |
|                                           |
|o3 = (e, {1, 2}, {0, 0})                   |
+-------------------------------------------+

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

  * toString(FreeOIModule) -- display a free
    OI-module in condensed form

FreeOIModule _ ZZ -- get the width n component of a free OI-module
******************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        F _ n
  * Inputs:
      * F, an instance of the type FreeOIModule,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type ModuleInWidth,

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

Returns the module in width n of a free OI-module.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : F_5                                                                     |
|                                                                             |
|                                                                     15      |
|o3 = (QQ[x   , x   , x   , x   , x   , x   , x   , x   , x   , x   ])   in   |
|          2,5   2,4   2,3   2,2   2,1   1,5   1,4   1,3   1,2   1,1          |
|                                                                             |
|o3 : ModuleInWidth                                                           |
|-----------------------------------------------------------------------------|
|width 5                                                                      |
+-----------------------------------------------------------------------------+

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

  * FreeOIModule _ ZZ -- get the width n component
    of a free OI-module

degree(VectorInWidth) -- get the degree of an element of a free OI-module
*************************************************************************

Synopsis
========

  * Function: degree (Macaulay2Doc),
  * Usage:
        degree f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an integer (Macaulay2Doc),

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

Returns the degree of the lead term of an element of a free OI-module.

+------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                       |
+------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                           |
+------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                              |
+------------------------------------------------------------------+
|i4 : f = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2)|
|                                                                  |
|o4 = x   x   e        + x   x   e                                 |
|      1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                       |
|                                                                  |
|                                             6                    |
|o4 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i5 : degree f                                                     |
|                                                                  |
|o5 = 2                                                            |
+------------------------------------------------------------------+

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

  * degree(VectorInWidth) -- get the degree
    of an element of a free OI-module

use(ModuleInWidth) -- use a component of a free OI-module
*********************************************************

Synopsis
========

  * Function: use (Macaulay2Doc),
  * Usage:
        use M
  * Inputs:
      * M, an instance of the type ModuleInWidth,

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

This method invokes use (Macaulay2Doc), on the underlying polynomial
ring of M. This is useful since distinct components of a free OI-module need
not be modules over the same polynomial ring.

+----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                 |
+----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                                   |
+----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 1);                                        |
+----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                        |
+----------------------------------------------------------------------------+
|i5 : use F_1; b1 = x_(1,1)*e_(1,{1},1)+x_(2,1)*e_(1,{1},2)                  |
|                                                                            |
|o6 = x   e        + x   e                                                   |
|      1,1 1,{1},1    2,1 1,{1},2                                            |
|                                                                            |
|                     2                                                      |
|o6 : (QQ[x   , x   ])  in width 1                                           |
|          2,1   1,1                                                         |
+----------------------------------------------------------------------------+
|i7 : use F_2; b2 = x_(1,2)*x_(1,1)*e_(2,{2},2)+x_(2,2)*x_(2,1)*e_(2,{1,2},3)|
|                                                                            |
|o8 = x   x   e        + x   x   e                                           |
|      1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3                                 |
|                                                                            |
|                                 5                                          |
|o8 : (QQ[x   , x   , x   , x   ])  in width 2                               |
|          2,2   2,1   1,2   1,1                                             |
+----------------------------------------------------------------------------+

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

  * use(ModuleInWidth) -- use a component of a
    free OI-module

terms(VectorInWidth) -- get the terms of an element of a free OI-module
***********************************************************************

Synopsis
========

  * Function: terms (Macaulay2Doc),
  * Usage:
        terms f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the list of terms of an element of a free OI-module.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e |
|                                                                             |
|o4 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|_(2,{2},2)                                                                   |
+-----------------------------------------------------------------------------+
|i5 : terms f                                                                 |
|                                                                             |
|o5 = {x   e       , -x   e       , x   e       , -x   e       }              |
|       1,1 2,{1},1    1,2 2,{2},1   2,1 2,{1},2    2,2 2,{2},2               |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The list of terms need not be in order. To find the lead term of an element,
see leadTerm(VectorInWidth).

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

  * terms(VectorInWidth) -- get the terms of
    an element of a free OI-module

leadTerm(VectorInWidth) -- get the lead term of an element of a free OI-module
******************************************************************************

Synopsis
========

  * Function: leadTerm (Macaulay2Doc),
  * Usage:
        leadTerm f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Returns the lead term of an element of a free OI-module according to the
specified OIMonomialOrder.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e |
|                                                                             |
|o4 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|_(2,{2},2)                                                                   |
+-----------------------------------------------------------------------------+
|i5 : leadTerm f                                                              |
|                                                                             |
|o5 = -x   e                                                                  |
|       1,2 2,{2},1                                                           |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+

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

  * leadTerm(VectorInWidth) -- get the lead
    term of an element of a free OI-module

leadMonomial(VectorInWidth) -- get the lead monomial of an element of a free OI-module
**************************************************************************************

Synopsis
========

  * Function: leadMonomial (Macaulay2Doc),
  * Usage:
        leadMonomial f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Returns the lead monomial of an element of a free OI-module according to the
specified OIMonomialOrder.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e |
|                                                                             |
|o4 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|_(2,{2},2)                                                                   |
+-----------------------------------------------------------------------------+
|i5 : leadMonomial f                                                          |
|                                                                             |
|o5 = x   e                                                                   |
|      1,2 2,{2},1                                                            |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+

Caveat
======

Asking for the lead monomial of a zero element will cause an error.

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

  * leadMonomial(VectorInWidth) -- get
    the lead monomial of an element of a free OI-module

leadCoefficient(VectorInWidth) -- get the lead coefficient of an element of a free OI-module
********************************************************************************************

Synopsis
========

  * Function: leadCoefficient (Macaulay2Doc),
  * Usage:
        leadCoefficient f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Returns the lead coefficient of an element of a free OI-module according to the
specified OIMonomialOrder.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-5*x_(1,2)*e_(2,{2},1)-x_(2,2)*|
|                                                                             |
|o4 = -5x   e        + x   e        - x   e        + x   e                    |
|        1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2             |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|e_(2,{2},2)                                                                  |
+-----------------------------------------------------------------------------+
|i5 : leadCoefficient f                                                       |
|                                                                             |
|o5 = -5                                                                      |
|                                                                             |
|o5 : QQ                                                                      |
+-----------------------------------------------------------------------------+

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

  * leadCoefficient(VectorInWidth),
    -- get the lead coefficient of an element of a free OI-module

Number * VectorInWidth -- multiply an element of a free OI-module by a number
*****************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        n * f
  * Inputs:
      * n, a number (Macaulay2Doc),
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Multiplies f by n.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-5*x_(1,2)*e_(2,{2},1)-x_(2,2)*|
|                                                                             |
|o4 = -5x   e        + x   e        - x   e        + x   e                    |
|        1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2             |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|e_(2,{2},2)                                                                  |
+-----------------------------------------------------------------------------+
|i5 : 22*f                                                                    |
|                                                                             |
|o5 = -110x   e        + 22x   e        - 22x   e        + 22x   e            |
|          1,2 2,{2},1      1,1 2,{1},1      2,2 2,{2},2      2,1 2,{1},2     |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+

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

  * Number * VectorInWidth -- multiply an
    element of a free OI-module by a number

VectorInWidth + VectorInWidth -- add two elements of a free OI-module
*********************************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        f + g
  * Inputs:
      * f, an instance of the type VectorInWidth,
      * g, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Adds f and g.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-5*x_(1,2)*e_(2,{2},1)-x_(2,2)*|
|                                                                             |
|o4 = -5x   e        + x   e        - x   e        + x   e                    |
|        1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2             |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|e_(2,{2},2)                                                                  |
+-----------------------------------------------------------------------------+
|i5 : g = 5*x_(1,2)*e_(2,{2},1)                                               |
|                                                                             |
|o5 = 5x   e                                                                  |
|       1,2 2,{2},1                                                           |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+
|i6 : f + g                                                                   |
|                                                                             |
|o6 = x   e        - x   e        + x   e                                     |
|      1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2                              |
|                                                                             |
|                                 4                                           |
|o6 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
+-----------------------------------------------------------------------------+

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

  * VectorInWidth + VectorInWidth -- add
    two elements of a free OI-module

RingElement * VectorInWidth -- multiply an element of a free OI-module by a ring element
****************************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        r * f
  * Inputs:
      * r, a ring element (Macaulay2Doc),
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Multiplies f by r provided that r belongs to the underlying polynomial ring of
the component in which f lives.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : f=x_(1,1)*e_(2,{1},1)+x_(2,1)*e_(2,{1},2)-x_(1,2)*e_(2,{2},1)-x_(2,2)*e |
|                                                                             |
|o4 = -x   e        + x   e        - x   e        + x   e                     |
|       1,2 2,{2},1    1,1 2,{1},1    2,2 2,{2},2    2,1 2,{1},2              |
|                                                                             |
|                                 4                                           |
|o4 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
|_(2,{2},2)                                                                   |
+-----------------------------------------------------------------------------+
|i5 : (x_(1,2)+x_(2,2)^2)*f                                                   |
|                                                                             |
|       2                  2              2                                   |
|o5 = -x   x   e        - x   e        + x   x   e        + x   x   e        -|
|       2,2 1,2 2,{2},1    1,2 2,{2},1    2,2 1,1 2,{1},1    1,2 1,1 2,{1},1  |
|                                                                             |
|                                 4                                           |
|o5 : (QQ[x   , x   , x   , x   ])  in width 2                                |
|          2,2   2,1   1,2   1,1                                              |
|-----------------------------------------------------------------------------|
| 3                                 2                                         |
|x   e        - x   x   e        + x   x   e        + x   x   e               |
| 2,2 2,{2},2    2,2 1,2 2,{2},2    2,2 2,1 2,{1},2    2,1 1,2 2,{1},2        |
+-----------------------------------------------------------------------------+

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

  * RingElement * VectorInWidth, --
    multiply an element of a free OI-module by a ring element

- VectorInWidth -- multiply an element of a free OI-module by -1
****************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        - f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Flips the sign of an element of a free OI-module.

+------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                       |
+------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                           |
+------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                              |
+------------------------------------------------------------------+
|i4 : f = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2)|
|                                                                  |
|o4 = x   x   e        + x   x   e                                 |
|      1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                       |
|                                                                  |
|                                             6                    |
|o4 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i5 : -f                                                           |
|                                                                  |
|o5 = -x   x   e        - x   x   e                                |
|       1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                      |
|                                                                  |
|                                             6                    |
|o5 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+

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

  * - VectorInWidth -- multiply an element of a free
    OI-module by -1

VectorInWidth - VectorInWidth -- subtract an element of a free OI-module from another
*************************************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        f - g
  * Inputs:
      * f, an instance of the type VectorInWidth,
      * g, an instance of the type VectorInWidth,
  * Outputs:
      * an instance of the type VectorInWidth,

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

Subtracts g from f.

+------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                       |
+------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                           |
+------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                              |
+------------------------------------------------------------------+
|i4 : f = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2)|
|                                                                  |
|o4 = x   x   e        + x   x   e                                 |
|      1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                       |
|                                                                  |
|                                             6                    |
|o4 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i5 : g = x_(2,2)*x_(2,1)*e_(3,{1,3},2)+x_(2,1)*e_(3,{1,2},2)      |
|                                                                  |
|o5 = x   x   e           + x   e                                  |
|      2,2 2,1 3,{1, 3},2    2,1 3,{1, 2},2                        |
|                                                                  |
|                                             6                    |
|o5 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i6 : f - g                                                        |
|                                                                  |
|o6 = x   x   e        - x   e                                     |
|      1,2 1,1 3,{2},1    2,1 3,{1, 2},2                           |
|                                                                  |
|                                             6                    |
|o6 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+

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

  * VectorInWidth - VectorInWidth, --
    subtract an element of a free OI-module from another

describe(FreeOIModuleMap) -- display a free OI-module map
*********************************************************

Synopsis
========

  * Function: describe (Macaulay2Doc),
  * Usage:
        describe phi
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the source module, target module, and basis element images of a free
OI-module map.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);          |
+-----------------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2);                                                      |
+-----------------------------------------------------------------------------+
|i6 : phi = C.dd_1;                                                           |
+-----------------------------------------------------------------------------+
|i7 : describe phi                                                            |
|                                                                             |
|o7 = Source: (e1, {5, 5}, {-4, -3}) Target: (e0, {3}, {-2})                  |
|     Basis element images: {x   x   e0              - x   x   e0             |
|                             2,3 1,1  5,{2, 4, 5},1    2,4 1,1  5,{2, 3, 5},1|
|     ------------------------------------------------------------------------|
|     - x   x   e0              + x   x   e0             , -x   e0            |
|        2,3 1,2  5,{1, 4, 5},1    2,4 1,2  5,{1, 3, 5},1    2,2  5,{1, 3,    |
|     ------------------------------------------------------------------------|
|          + x   e0              + x   e0              - x   e0             } |
|     5},1    2,2  5,{1, 3, 4},1    2,3  5,{1, 2, 5},1    2,3  5,{1, 2, 4},1  |
+-----------------------------------------------------------------------------+

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

  * describe(FreeOIModuleMap) -- display
    a free OI-module map

isHomogeneous(FreeOIModuleMap) -- checks if a free OI-module map is homogeneous
*******************************************************************************

Synopsis
========

  * Function: isHomogeneous (Macaulay2Doc),
  * Usage:
        isHomogeneous phi
  * Inputs:
      * phi, an instance of the type FreeOIModuleMap,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if a map of free OI-modules is homogeneous, i.e., if it preserves
degrees of elements.

+-------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                        |
+-------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                            |
+-------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                               |
+-------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2);|
+-------------------------------------------------------------------+
|i5 : C = oiRes({b}, 2);                                            |
+-------------------------------------------------------------------+
|i6 : phi = C.dd_1                                                  |
|                                                                   |
|o6 = Source: (e1, {5, 5}, {-4, -3}) Target: (e0, {3}, {-2})        |
|                                                                   |
|o6 : FreeOIModuleMap                                               |
+-------------------------------------------------------------------+
|i7 : isHomogeneous phi                                             |
|                                                                   |
|o7 = true                                                          |
+-------------------------------------------------------------------+

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

  * isHomogeneous(FreeOIModuleMap),
    -- checks if a free OI-module map is homogeneous

isHomogeneous(VectorInWidth) -- check if an element of a free OI-module is homogeneous
**************************************************************************************

Synopsis
========

  * Function: isHomogeneous (Macaulay2Doc),
  * Usage:
        isHomogeneous f
  * Inputs:
      * f, an instance of the type VectorInWidth,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if an element of a free OI-module is homogeneous, i.e., if every term
has the same degree.

+------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                       |
+------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,2}, P);                           |
+------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 3);                              |
+------------------------------------------------------------------+
|i4 : f = x_(1,2)*x_(1,1)*e_(3,{2},1)+x_(2,2)*x_(2,1)*e_(3,{1,3},2)|
|                                                                  |
|o4 = x   x   e        + x   x   e                                 |
|      1,2 1,1 3,{2},1    2,2 2,1 3,{1, 3},2                       |
|                                                                  |
|                                             6                    |
|o4 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i5 : g = x_(2,2)*x_(2,1)*e_(3,{1,3},2)+x_(2,1)*e_(3,{1,2},2)      |
|                                                                  |
|o5 = x   x   e           + x   e                                  |
|      2,2 2,1 3,{1, 3},2    2,1 3,{1, 2},2                        |
|                                                                  |
|                                             6                    |
|o5 : (QQ[x   , x   , x   , x   , x   , x   ])  in width 3         |
|          2,3   2,2   2,1   1,3   1,2   1,1                       |
+------------------------------------------------------------------+
|i6 : isHomogeneous f                                              |
|                                                                  |
|o6 = true                                                         |
+------------------------------------------------------------------+
|i7 : isHomogeneous g                                              |
|                                                                  |
|o7 = false                                                        |
+------------------------------------------------------------------+

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

  * isHomogeneous(VectorInWidth), --
    check if an element of a free OI-module is homogeneous

oiGB -- compute a Gröbner basis for a submodule of a free OI-module
*******************************************************************

Synopsis
========

  * Usage:
        oiGB L
  * Inputs:
      * L, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value Minimize
      * Verbose => ..., default value false
  * Outputs:
      * a list (Macaulay2Doc),

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

Given a list of elements L belonging to a free OI-module $\mathbf{F}$, this
method computes a Gröbner basis for the submodule generated by L with respect
to the monomial order of $\mathbf{F}$. The Verbose (Macaulay2Doc),
option must be either true or false, depending on
whether one wants debug information printed.

The Strategy (Macaulay2Doc), option has the following
permissible values:

  * Strategy => "FastNonminimal" for no post-processing of the basis
  * Strategy => "Minimize" to minimize the basis after it is computed; see
    minimizeOIGB,
  * Strategy => "Reduce" to reduce the basis after it is computed; see
    reduceOIGB,
+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                                    |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 1);                                         |
+-----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i5 : use F_1; b1 = x_(1,1)*e_(1,{1},1)+x_(2,1)*e_(1,{1},2);                  |
+-----------------------------------------------------------------------------+
|i7 : use F_2; b2 = x_(1,2)*x_(1,1)*e_(2,{2},2)+x_(2,2)*x_(2,1)*e_(2,{1,2},3);|
+-----------------------------------------------------------------------------+
|i9 : time oiGB {b1, b2}                                                      |
| -- used 0.021s (cpu); 0.020874s (thread); 0s (gc)                           |
|                                                                             |
|o9 = {x   e        + x   e       , x   x   e        + x   x   e          ,   |
|       1,1 1,{1},1    2,1 1,{1},2   1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3    |
|     ------------------------------------------------------------------------|
|     x   x   x   e           - x   x   x   e          }                      |
|      2,3 2,2 1,1 3,{2, 3},3    2,3 2,1 1,2 3,{1, 3},3                       |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use oiGB:
=================

  * "oiGB(List)"

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

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

minimizeOIGB -- minimize an OI-Gröbner basis
********************************************

Synopsis
========

  * Usage:
        minimizeOIGB G
  * Inputs:
      * G, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Verbose => ..., default value false
  * Outputs:
      * a list (Macaulay2Doc),

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

This method minimizes G with respect to the Gröbner property, i.e., removes any
elements whose leading monomial is OI-divisible by the leading monomial of
another element of G. The Verbose (Macaulay2Doc), option must be
either true or false, depending on whether one wants debug information printed.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                                    |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 1);                                         |
+-----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i5 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i6 : use F_1; b1 = x_(1,1)*e_(1,{1},1)+x_(2,1)*e_(1,{1},2);                  |
+-----------------------------------------------------------------------------+
|i8 : use F_2; b2 = x_(1,2)*x_(1,1)*e_(2,{2},2)+x_(2,2)*x_(2,1)*e_(2,{1,2},3);|
+-----------------------------------------------------------------------------+
|i10 : time B = oiGB {b1, b2}                                                 |
| -- used 0.0200001s (cpu); 0.0200532s (thread); 0s (gc)                      |
|                                                                             |
|o10 = {x   e        + x   e       , x   x   e        + x   x   e          ,  |
|        1,1 1,{1},1    2,1 1,{1},2   1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3   |
|      -----------------------------------------------------------------------|
|      x   x   x   e           - x   x   x   e          }                     |
|       2,3 2,2 1,1 3,{2, 3},3    2,3 2,1 1,2 3,{1, 3},3                      |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : use F_3; b3 = x_(2,3)*x_(2,2)*x_(1,1)*e_(3,{2,3},3)-x_(2,1)*x_(1,2)^2*e|
|-----------------------------------------------------------------------------|
|_(3,{1,3},3);                                                                |
+-----------------------------------------------------------------------------+
|i13 : C = append(B, b3) -- dump in a redundant element                       |
|                                                                             |
|                                                                             |
|o13 = {x   e        + x   e       , x   x   e        + x   x   e          ,  |
|        1,1 1,{1},1    2,1 1,{1},2   1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3   |
|      -----------------------------------------------------------------------|
|                                                                             |
|      x   x   x   e           - x   x   x   e          , x   x   x   e       |
|       2,3 2,2 1,1 3,{2, 3},3    2,3 2,1 1,2 3,{1, 3},3   2,3 2,2 1,1 3,{2,  |
|      -----------------------------------------------------------------------|
|                  2                                                          |
|           - x   x   e          }                                            |
|      3},3    2,1 1,2 3,{1, 3},3                                             |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : minimizeOIGB C -- an element gets removed                              |
|                                                                             |
|                                                                             |
|o14 = {x   e        + x   e       , x   x   e        + x   x   e          ,  |
|        1,1 1,{1},1    2,1 1,{1},2   1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3   |
|      -----------------------------------------------------------------------|
|                                     2                                       |
|      x   x   x   e           - x   x   e          }                         |
|       2,3 2,2 1,1 3,{2, 3},3    2,1 1,2 3,{1, 3},3                          |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use minimizeOIGB:
=========================

  * "minimizeOIGB(List)"

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

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

reduceOIGB -- reduce an OI-Gröbner basis
****************************************

Synopsis
========

  * Usage:
        reduceOIGB G
  * Inputs:
      * G, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Verbose => ..., default value false
  * Outputs:
      * a list (Macaulay2Doc),

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

This method reduces G as a Gröbner basis, i.e., ensures that no monomial of any
element of G is OI-divisible by the leading monomial of any other element of G.
The Verbose (Macaulay2Doc), option must be either true or false,
depending on whether one wants debug information printed.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                                    |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 1);                                         |
+-----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i5 : use F_1; b1 = x_(2,1)*e_(1,{1},2)+x_(1,1)*e_(1,{1},2);                  |
+-----------------------------------------------------------------------------+
|i7 : use F_2; b2 = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(1,2)*e_(2,{2},2);  |
+-----------------------------------------------------------------------------+
|i9 : time B = oiGB({b1, b2}, Strategy => FastNonminimal)                     |
| -- used 0.121128s (cpu); 0.0951431s (thread); 0s (gc)                       |
|                                                                             |
|                                                                             |
|o9 = {x   e        + x   e       , x   x   e        + x   x   e       ,      |
|       2,1 1,{1},2    1,1 1,{1},2   1,2 1,1 2,{2},1    2,2 1,2 2,{2},2       |
|     ------------------------------------------------------------------------|
|      2                  2                                                   |
|     x   x   e        - x   x   e       }                                    |
|      1,3 1,2 3,{3},2    1,3 1,1 3,{3},2                                     |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : minimizeOIGB B -- does not change the basis                            |
|                                                                             |
|                                                                             |
|o10 = {x   e        + x   e       , x   x   e        + x   x   e       ,     |
|        2,1 1,{1},2    1,1 1,{1},2   1,2 1,1 2,{2},1    2,2 1,2 2,{2},2      |
|      -----------------------------------------------------------------------|
|       2                  2                                                  |
|      x   x   e        - x   x   e       }                                   |
|       1,3 1,2 3,{3},2    1,3 1,1 3,{3},2                                    |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : reduceOIGB B -- changes the basis                                      |
|                                                                             |
|                                                        2                    |
|o11 = {x   e        + x   e       , x   x   e        - x   e       ,         |
|        2,1 1,{1},2    1,1 1,{1},2   1,2 1,1 2,{2},1    1,2 2,{2},2          |
|      -----------------------------------------------------------------------|
|       2                  2                                                  |
|      x   x   e        - x   x   e       }                                   |
|       1,3 1,2 3,{3},2    1,3 1,1 3,{3},2                                    |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use reduceOIGB:
=======================

  * "reduceOIGB(List)"

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

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

isOIGB -- check if a list of elements of a free OI-module forms a Gröbner basis
*******************************************************************************

Synopsis
========

  * Usage:
        isOIGB L
  * Inputs:
      * L, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Verbose => ..., default value false
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks if a L forms a Gröbner basis for the submodule it generates. The
Verbose (Macaulay2Doc), option must be either true or false, depending
on whether one wants debug information printed.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1,2}, P);                                    |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 1);                                         |
+-----------------------------------------------------------------------------+
|i4 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i5 : installGeneratorsInWidth(F, 3);                                         |
+-----------------------------------------------------------------------------+
|i6 : use F_1; b1 = x_(1,1)*e_(1,{1},1)+x_(2,1)*e_(1,{1},2);                  |
+-----------------------------------------------------------------------------+
|i8 : use F_2; b2 = x_(1,2)*x_(1,1)*e_(2,{2},2)+x_(2,2)*x_(2,1)*e_(2,{1,2},3);|
+-----------------------------------------------------------------------------+
|i10 : isOIGB {b1, b2}                                                        |
|                                                                             |
|o10 = false                                                                  |
+-----------------------------------------------------------------------------+
|i11 : time B = oiGB {b1, b2}                                                 |
| -- used 0.0180002s (cpu); 0.0180967s (thread); 0s (gc)                      |
|                                                                             |
|o11 = {x   e        + x   e       , x   x   e        + x   x   e          ,  |
|        1,1 1,{1},1    2,1 1,{1},2   1,2 1,1 2,{2},2    2,2 2,1 2,{1, 2},3   |
|      -----------------------------------------------------------------------|
|      x   x   x   e           - x   x   x   e          }                     |
|       2,3 2,2 1,1 3,{2, 3},3    2,3 2,1 1,2 3,{1, 3},3                      |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : isOIGB B                                                               |
|                                                                             |
|o12 = true                                                                   |
+-----------------------------------------------------------------------------+

Ways to use isOIGB:
===================

  * "isOIGB(List)"

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

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

oiSyz -- compute a Gröbner basis for the syzygy module of a submodule of a free OI-module
*****************************************************************************************

Synopsis
========

  * Usage:
        oiSyz(G, d)
  * Inputs:
      * G, a list (Macaulay2Doc),
      * d, a symbol (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value Minimize
      * Verbose => ..., default value false
  * Outputs:
      * a list (Macaulay2Doc),

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

Given a non-empty Gröbner basis G for a submodule $\mathbf{M}$ of a free
OI-module $\mathbf{F}$, this method computes a Gröbner basis $G'$ for the
syzygy module of $\mathbf{M}$ with respect to the Schreyer order induced by
$G$; see OIMonomialOrder.

The new Gröbner basis $G'$ lives in an appropriate free OI-module $\mathbf{G}$
with basis symbol d whose basis elements are mapped onto the elements of $G$ by
a canonical surjective map $\varphi:\mathbf{G}\to\mathbf{M}$ (see Definition
4.1 of [1]). Moreover, the degrees of the basis elements of $\mathbf{G}$ are
automatically shifted to coincide with the degrees of the elements of $G$, so
that $\varphi$ is homogeneous if $G$ consists of homogeneous elements. If $G'$
is not empty, then one obtains $\mathbf{G}$ by applying getFreeOIModule,
to any element of $G'$. One obtains $\varphi$ by using
getSchreyerMap.

The Verbose (Macaulay2Doc), option must be either true or false,
depending on whether one wants debug information printed.

The Strategy (Macaulay2Doc), option has the following
permissible values:

  * Strategy => "FastNonminimal" for no post-processing of the basis
  * Strategy => "Minimize" to minimize the basis after it is computed; see
    minimizeOIGB,
  * Strategy => "Reduce" to reduce the basis after it is computed; see
    reduceOIGB,
+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);            |
+-----------------------------------------------------------------------------+
|i5 : G = oiGB {b}                                                            |
|                                                                             |
|o5 = {x   x   e        + x   x   e       , x   x   x   e        -            |
|       1,2 1,1 2,{2},1    2,2 2,1 2,{1},2   2,3 2,2 1,1 3,{2},2              |
|     ------------------------------------------------------------------------|
|     x   x   x   e       }                                                   |
|      2,3 2,1 1,2 3,{1},2                                                    |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : oiSyz(G, d)                                                             |
|                                                                             |
|o6 = {x   d           - x   d           + 1d             , x   d             |
|       1,2 3,{1, 3},1    1,1 3,{2, 3},1     3,{1, 2, 3},2   2,4 4,{1, 2, 3},2|
|     ------------------------------------------------------------------------|
|     - x   d             , x   d              - x   d              -         |
|        2,3 4,{1, 2, 4},2   1,2 4,{1, 3, 4},2    1,1 4,{2, 3, 4},2           |
|     ------------------------------------------------------------------------|
|     x   d             }                                                     |
|      1,3 4,{1, 2, 4},2                                                      |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

References:

[1] M. Morrow and U. Nagel, Computing Gröbner Bases and Free Resolutions of
OI-Modules, Preprint, arXiv:2303.06725, 2023.

Ways to use oiSyz:
==================

  * "oiSyz(List,Symbol)"

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

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

OIResolution -- the class of all resolutions of submodules of free OI-modules
*****************************************************************************

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

This type implements free resolutions of submodules of free OI-modules. To make
an OIResolution object, use oiRes. To verify that an
OI-resolution is a complex, use isComplex. To get the $n$th
differential in an OI-resolution C, use C.dd_n.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time C = oiRes({b}, 1)                                      |
| -- used 0.101266s (cpu); 0.074397s (thread); 0s (gc)            |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4, 4}, {-4, -4})                                   |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+
|i6 : C.dd_0                                                      |
|                                                                 |
|o6 = Source: (e0, {2}, {-2}) Target: (e, {1, 1}, {0, 0})         |
|                                                                 |
|o6 : FreeOIModuleMap                                             |
+-----------------------------------------------------------------+

Functions and methods returning an object of class OIResolution:
================================================================

  * oiRes -- compute an OI-resolution

Methods that use an object of class OIResolution:
=================================================

  * describe(OIResolution) -- describe an
    OI-resolution
  * "describeFull(OIResolution)" -- see describeFull, --
    describe an OI-resolution and the maps
  * "isComplex(OIResolution)" -- see isComplex, -- verify that
    an OI-resolution is a complex
  * net(OIResolution) -- display an OI-resolution
  * OIResolution _ ZZ -- get a module of an
    OI-resolution is specified homological degree
  * "ranks(OIResolution)" -- see ranks, -- display the ranks of an
    OI-resolution
  * "restrictedRanks(OIResolution,ZZ)" -- see restrictedRanks,
    -- display the ranks of an OI-resolution restricted to a
    given width

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

The object OIResolution, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

oiRes -- compute an OI-resolution
*********************************

Synopsis
========

  * Usage:
        oiRes(L, n)
  * Inputs:
      * L, a list (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value Minimize
      * TopNonminimal => ..., default value false
      * Verbose => ..., default value false
  * Outputs:
      * an instance of the type OIResolution,

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

Computes an OI-resolution of the submodule generated by L out to homological
degree n. If L consists of homogeneous elements, then the resulting resolution
will be graded and minimal out to homological degree $n-1$. The Verbose (Macaulay2Doc),
option must be either true or false, depending on
whether one wants debug information printed.

The Strategy (Macaulay2Doc), option has the following
permissible values:

  * Strategy => "FastNonminimal" for no post-processing of the Gröbner basis
    computed at each step
  * Strategy => "Minimize" to minimize the Gröbner basis after it is computed
    at each step; see minimizeOIGB,
  * Strategy => "Reduce" to reduce the Gröbner basis after it is computed at
    each step; see reduceOIGB,

The TopNonminimal, option must be either true or false,
depending on whether one wants the Gröbner basis in homological degree $n-1$ to
be minimized. Therefore, use TopNonminimal => true for no minimization of the
basis in degree $n-1$.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time oiRes({b}, 2, TopNonminimal => true)                   |
| -- used 0.235564s (cpu); 0.180886s (thread); 0s (gc)            |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4}, {-4})                                          |
|     2: (e2, {4, 5, 5, 5, 5, 5}, {-4, -5, -5, -5, -5, -5})       |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+

Ways to use oiRes:
==================

  * "oiRes(List,ZZ)"

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

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

ranks -- display the ranks of an OI-resolution
**********************************************

Synopsis
========

  * Usage:
        ranks C
  * Inputs:
      * C, an instance of the type OIResolution,
  * Outputs:
      * a net (Macaulay2Doc),

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

Given an OI-resolution $C$, this method displays the ranks of the modules in
$C$.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : C = oiRes({b}, 2)                                           |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4}, {-4})                                          |
|     2: (e2, {5, 5, 5}, {-5, -5, -5})                            |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+
|i6 : ranks C                                                     |
|                                                                 |
|o6 = 0: rank 1                                                   |
|     1: rank 1                                                   |
|     2: rank 3                                                   |
+-----------------------------------------------------------------+

Ways to use ranks:
==================

  * "ranks(OIResolution)"

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

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

restrictedRanks -- display the ranks of an OI-resolution restricted to a given width
************************************************************************************

Synopsis
========

  * Usage:
        restrictedRanks(C,w)
  * Inputs:
      * C, an instance of the type OIResolution,
      * w, an integer (Macaulay2Doc),
  * Outputs:
      * a net (Macaulay2Doc),

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

Given an OI-resolution $C$ and a width $w$, this method displays the ranks of
the modules in $C$ restricted to width $w$.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : C = oiRes({b}, 2)                                           |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4}, {-4})                                          |
|     2: (e2, {5, 5, 5}, {-5, -5, -5})                            |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+
|i6 : ranks C                                                     |
|                                                                 |
|o6 = 0: rank 1                                                   |
|     1: rank 1                                                   |
|     2: rank 3                                                   |
+-----------------------------------------------------------------+
|i7 : restrictedRanks(C,5)                                        |
|                                                                 |
|o7 = 0: rank 10                                                  |
|     1: rank 5                                                   |
|     2: rank 3                                                   |
+-----------------------------------------------------------------+

Ways to use restrictedRanks:
============================

  * "restrictedRanks(OIResolution,ZZ)"

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

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

TopNonminimal -- option for minimizing the top Gröbner basis of an OI-resolution
********************************************************************************

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

Used as an optional argument in the oiRes, method. The
TopNonminimal option must be either true or false, depending on whether one
wants the Gröbner basis in homological degree $n-1$ to be minimized. Therefore,
use TopNonminimal => true for no minimization of the basis in degree $n-1$.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time oiRes({b}, 2, TopNonminimal => true)                   |
| -- used 0.237158s (cpu); 0.183778s (thread); 0s (gc)            |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4}, {-4})                                          |
|     2: (e2, {4, 5, 5, 5, 5, 5}, {-4, -5, -5, -5, -5, -5})       |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+

Functions with optional argument named TopNonminimal:
=====================================================

  * "oiRes(...,TopNonminimal=>...)" -- see oiRes, -- compute an
    OI-resolution

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

The object TopNonminimal, is a symbol (Macaulay2Doc).

isComplex -- verify that an OI-resolution is a complex
******************************************************

Synopsis
========

  * Usage:
        isComplex C
  * Inputs:
      * C, an instance of the type OIResolution,
  * Optional inputs (Macaulay2Doc),:
      * Verbose => ..., default value false
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This method verifies that an OI-resolution is indeed a complex. The
Verbose (Macaulay2Doc), option must be either true or false, depending
on whether one wants debug information printed.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time C = oiRes({b}, 2, TopNonminimal => true)               |
| -- used 0.246399s (cpu); 0.195168s (thread); 0s (gc)            |
|                                                                 |
|o5 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4}, {-4})                                          |
|     2: (e2, {4, 5, 5, 5, 5, 5}, {-4, -5, -5, -5, -5, -5})       |
|                                                                 |
|o5 : OIResolution                                                |
+-----------------------------------------------------------------+
|i6 : isComplex C                                                 |
|                                                                 |
|o6 = true                                                        |
+-----------------------------------------------------------------+

Ways to use isComplex:
======================

  * "isComplex(OIResolution)"

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

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

describeFull -- describe an OI-resolution and the maps
******************************************************

Synopsis
========

  * Usage:
        describe C
  * Inputs:
      * C, an instance of the type OIResolution,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the free OI-modules and describes the differentials of an
OI-resolution.

+-----------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                                  |
+-----------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                      |
+-----------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                         |
+-----------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);            |
+-----------------------------------------------------------------------------+
|i5 : time C = oiRes({b}, 1);                                                 |
| -- used 0.101617s (cpu); 0.0744935s (thread); 0s (gc)                       |
+-----------------------------------------------------------------------------+
|i6 : describeFull C                                                          |
|                                                                             |
|o6 = 0: Module: Basis symbol: e0                                             |
|                Basis element widths: {2}                                    |
|                Degree shifts: {-2}                                          |
|                Polynomial OI-algebra: (2, x, QQ, RowUpColUp)                |
|                Monomial order: Lex                                          |
|     Differential: Source: (e0, {2}, {-2}) Target: (e, {1, 1}, {0, 0})       |
|     1: Module: Basis symbol: e1                                             |
|                Basis element widths: {4, 4}                                 |
|                Degree shifts: {-4, -4}                                      |
|                Polynomial OI-algebra: (2, x, QQ, RowUpColUp)                |
|                Monomial order: Lex                                          |
|     Differential: Source: (e1, {4, 4}, {-4, -4}) Target: (e0, {2}, {-2})    |
|                   Basis element images: {0, -x   x   e0           + x   x   |
|                                               2,3 1,1  4,{2, 4},1    2,4 1,1|
|-----------------------------------------------------------------------------|
|e0           + x   x   e0           - x   x   e0          }                  |
|  4,{2, 3},1    2,3 1,2  4,{1, 4},1    2,4 1,2  4,{1, 3},1                   |
+-----------------------------------------------------------------------------+

Ways to use describeFull:
=========================

  * "describeFull(OIResolution)"

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

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

describe(OIResolution) -- describe an OI-resolution
***************************************************

Synopsis
========

  * Function: describe (Macaulay2Doc),
  * Usage:
        describe C
  * Inputs:
      * C, an instance of the type OIResolution,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the free OI-modules and differentials of an OI-resolution.

+-------------------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                              |
+-------------------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                                  |
+-------------------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                                     |
+-------------------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);        |
+-------------------------------------------------------------------------+
|i5 : time C = oiRes({b}, 1);                                             |
| -- used 0.102385s (cpu); 0.0748159s (thread); 0s (gc)                   |
+-------------------------------------------------------------------------+
|i6 : describe C                                                          |
|                                                                         |
|o6 = 0: Module: Basis symbol: e0                                         |
|                Basis element widths: {2}                                |
|                Degree shifts: {-2}                                      |
|                Polynomial OI-algebra: (2, x, QQ, RowUpColUp)            |
|                Monomial order: Lex                                      |
|     Differential: Source: (e0, {2}, {-2}) Target: (e, {1, 1}, {0, 0})   |
|     1: Module: Basis symbol: e1                                         |
|                Basis element widths: {4, 4}                             |
|                Degree shifts: {-4, -4}                                  |
|                Polynomial OI-algebra: (2, x, QQ, RowUpColUp)            |
|                Monomial order: Lex                                      |
|     Differential: Source: (e1, {4, 4}, {-4, -4}) Target: (e0, {2}, {-2})|
+-------------------------------------------------------------------------+

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

  * describe(OIResolution) -- describe an
    OI-resolution

net(OIResolution) -- display an OI-resolution
*********************************************

Synopsis
========

  * Function: net (Macaulay2Doc),
  * Usage:
        net C
  * Inputs:
      * C, an instance of the type OIResolution,
  * Outputs:
      * a net (Macaulay2Doc),

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

Displays the basis element widths and degree shifts of the free OI-modules in
an OI-resolution.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time C = oiRes({b}, 1);                                     |
| -- used 0.103601s (cpu); 0.0763806s (thread); 0s (gc)           |
+-----------------------------------------------------------------+
|i6 : net C                                                       |
|                                                                 |
|o6 = 0: (e0, {2}, {-2})                                          |
|     1: (e1, {4, 4}, {-4, -4})                                   |
+-----------------------------------------------------------------+

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

  * net(OIResolution) -- display an OI-resolution

OIResolution _ ZZ -- get a module of an OI-resolution is specified homological degree
*************************************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),
  * Usage:
        C _ n
  * Inputs:
      * C, an instance of the type OIResolution,
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * an instance of the type FreeOIModule,

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

Returns the free OI-module of $C$ in homological degree $n$.

+-----------------------------------------------------------------+
|i1 : P = makePolynomialOIAlgebra(2, x, QQ);                      |
+-----------------------------------------------------------------+
|i2 : F = makeFreeOIModule(e, {1,1}, P);                          |
+-----------------------------------------------------------------+
|i3 : installGeneratorsInWidth(F, 2);                             |
+-----------------------------------------------------------------+
|i4 : b = x_(1,2)*x_(1,1)*e_(2,{2},1)+x_(2,2)*x_(2,1)*e_(2,{1},2);|
+-----------------------------------------------------------------+
|i5 : time C = oiRes({b}, 1);                                     |
| -- used 0.101745s (cpu); 0.0748749s (thread); 0s (gc)           |
+-----------------------------------------------------------------+
|i6 : C_0                                                         |
|                                                                 |
|o6 = Basis symbol: e0                                            |
|     Basis element widths: {2}                                   |
|     Degree shifts: {-2}                                         |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)               |
|     Monomial order: Lex                                         |
|                                                                 |
|o6 : FreeOIModule                                                |
+-----------------------------------------------------------------+
|i7 : C_1                                                         |
|                                                                 |
|o7 = Basis symbol: e1                                            |
|     Basis element widths: {4, 4}                                |
|     Degree shifts: {-4, -4}                                     |
|     Polynomial OI-algebra: (2, x, QQ, RowUpColUp)               |
|     Monomial order: Lex                                         |
|                                                                 |
|o7 : FreeOIModule                                                |
+-----------------------------------------------------------------+

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

  * OIResolution _ ZZ -- get a module of an
    OI-resolution is specified homological degree