This is LinearTruncations.info, produced by Macaulay2, version 1.22

LinearTruncations -- truncations of a multigraded module that give linear resolutions
*************************************************************************************

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

Let $k$ be a field, $S$ a $\ZZ^r$-graded polynomial ring over $k$, and $M$ a
finitely generated, $\ZZ^r$-graded $S$-module. Write $M_{\geq d}$ for the
truncation $\oplus_{d'\geq d} M_d'$ of $M$ at $d$ (where $d'\geq d$ if
$d'_i\geq d_i$ for all $i$). The main purpose of this package is to find the
degrees $d\in\ZZ^r$ so that $M_{\geq d}$ has a linear resolution, i.e.
satisfies the function isLinearComplex.  No sufficient
finite search space is known, so the result may not be complete.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[x_1..x_4,Degrees=>{{1,0},{1,0},{0,1},{0,1}}]                 |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_1^3*x_3, x_2*x_3*x_4, x_3^4*x_4, x_4*x_2^2, x_1^3*x_2^3,    |
|                                                                             |
|             3             4     2     3 3   3                               |
|o2 = ideal (x x , x x x , x x , x x , x x , x )                              |
|             1 3   2 3 4   3 4   2 4   1 2   3                               |
|                                                                             |
|o2 : Ideal of S                                                              |
|-----------------------------------------------------------------------------|
|x_3^3)                                                                       |
+-----------------------------------------------------------------------------+
|i3 : M = S^1/I                                                               |
|                                                                             |
|o3 = cokernel | x_1^3x_3 x_2x_3x_4 x_3^4x_4 x_2^2x_4 x_1^3x_2^3 x_3^3 |      |
|                                                                             |
|                            1                                                |
|o3 : S-module, quotient of S                                                 |
+-----------------------------------------------------------------------------+
|i4 : regularity M                                                            |
|                                                                             |
|o4 = 5                                                                       |
+-----------------------------------------------------------------------------+
|i5 : r = coarseMultigradedRegularity M                                       |
|                                                                             |
|o5 = {6, 4}                                                                  |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : L = linearTruncations({{0,0}, r}, M)                                    |
|                                                                             |
|o6 = {{2, 3}, {3, 2}}                                                        |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : apply(L, i -> isLinearComplex res truncate(i,M))                        |
|                                                                             |
|o7 = {true, true}                                                            |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

If $M_{\geq d}$ has a linear truncation then $M_{\geq d'}$ has a linear
truncation for all $d'\geq d$, so the function linearTruncations,
gives the minimal such multidegrees in a given range, using
the function findRegion.  The functions
linearTruncationsBound, and regularityBound,
estimate the linear truncation region and the multigraded
regularity region of $M$, respectively, without calculating cohomology or
truncations.

Caveat
======

If the ring $S$ is standard $\ZZ$-graded then $M_{\geq d}$ has a linear
resolution if and only if $d\geq\operatorname{reg} M$, where
$\operatorname{reg} M$ is the Castelnuovo-Mumford regularity of $M$.

See also
========

  * Truncations -- truncations of graded ring, ideals
    and modules

Authors
=======

  * Lauren Cranton Heller <lch@math.berkeley.edu>
  * David Eisenbud <de@msri.org>
  * Navid Nemati <Navid.Nemati@inria.fr>

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

Version 1.0 of this package was accepted for publication in volume 12 (see
https://msp.org/jsag/2022/12-1/ ) of The Journal of Software for Algebra and
Geometry (see http://j-sag.org/ ) on 18 May 2022, in the article Linear
truncations package for Macaulay2 (see https://msp.org/jsag/2022/12-1/p02.xhtml
). That version can be obtained from the journal (see
https://msp.org/jsag/2022/12-1/jsag-v12-n1-x02-LinearTruncations.m2 ) or from
the Macaulay2 source code repository (see
http://github.com/Macaulay2/M2/blob/c1b72330821054c17b07c574649d98ac577cb3af/M2
/Macaulay2/packages/LinearTruncations.m2 ).

Version
=======

This documentation describes version 1.0 of LinearTruncations.

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

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

Exports
=======

  * Functions and commands
      * "compMax" -- see compMin, -- takes componentwise minimum
        or maximum of a list of lists
      * compMin -- takes componentwise minimum or maximum of a
        list of lists
      * diagonalMultidegrees -- t-tuples of
        non-negative integers with sum equal to d
      * findMins -- calculates the minimal elements of a
        subset of ZZ^r
      * findRegion -- finds minimal multidegree(s) in a
        given region where an ideal or module satisfies a Boolean function
      * irrelevantIdeal -- gives the irrelevant ideal
        of the coordinate ring of a product of projective spaces
      * isLinearComplex -- tests whether a complex of
        graded modules is linear
      * isQuasiLinear -- checks whether degrees in the
        resolution of a truncation are at most those of the irrelevant ideal
      * linearTruncations -- finds minimal
        multidegree(s) in a given range where the resolution of a truncated
        module is linear
      * linearTruncationsBound -- bounds the
        region where truncations of a module have linear resolutions
      * multigradedPolynomialRing -- produces
        polynomial rings with standard multigradings
      * partialRegularities -- calculates
        Castelnuovo-Mumford regularity in each component of a multigrading
      * regularityBound -- bounds the multigraded
        regularity of a module
      * supportOfTor -- computes multidegrees in the
        support of Tor_i(M,k), where k is the residue field
  * Methods
      * "compMax(List)" -- see compMin, -- takes componentwise
        minimum or maximum of a list of lists
      * "compMax(List,List)" -- see compMin, -- takes
        componentwise minimum or maximum of a list of lists
      * "compMin(List)" -- see compMin, -- takes componentwise
        minimum or maximum of a list of lists
      * "compMin(List,List)" -- see compMin, -- takes
        componentwise minimum or maximum of a list of lists
      * "diagonalMultidegrees(ZZ,List)" -- see diagonalMultidegrees,
        -- t-tuples of non-negative integers with sum
        equal to d
      * "diagonalMultidegrees(ZZ,ZZ)" -- see diagonalMultidegrees,
        -- t-tuples of non-negative integers with sum
        equal to d
      * "findMins(Ideal)" -- see findMins, -- calculates the
        minimal elements of a subset of ZZ^r
      * "findMins(List)" -- see findMins, -- calculates the
        minimal elements of a subset of ZZ^r
      * "findRegion(List,Ideal,Function)" -- see findRegion,
        -- finds minimal multidegree(s) in a given region where an ideal or
        module satisfies a Boolean function
      * "findRegion(List,Module,Function)" -- see findRegion,
        -- finds minimal multidegree(s) in a given region where an ideal or
        module satisfies a Boolean function
      * "irrelevantIdeal(Ring)" -- see irrelevantIdeal,
        -- gives the irrelevant ideal of the coordinate ring of a product of
        projective spaces
      * "isLinearComplex(ChainComplex)" -- see isLinearComplex,
        -- tests whether a complex of graded modules is linear
      * "isQuasiLinear(BettiTally)" -- see isQuasiLinear,
        -- checks whether degrees in the resolution of a truncation are at most
        those of the irrelevant ideal
      * "isQuasiLinear(ChainComplex)" -- see isQuasiLinear,
        -- checks whether degrees in the resolution of a
        truncation are at most those of the irrelevant ideal
      * "isQuasiLinear(List,Module)" -- see isQuasiLinear,
        -- checks whether degrees in the resolution of a truncation are at most
        those of the irrelevant ideal
      * "linearTruncations(List,Module)" -- see linearTruncations,
        -- finds minimal multidegree(s) in a given range
        where the resolution of a truncated module is linear
      * "linearTruncations(Module)" -- see linearTruncations,
        -- finds minimal multidegree(s) in a given range
        where the resolution of a truncated module is linear
      * "linearTruncationsBound(Module)" -- see linearTruncationsBound,
        -- bounds the region where truncations of a
        module have linear resolutions
      * "multigradedPolynomialRing(List)" -- see
        multigradedPolynomialRing, -- produces
        polynomial rings with standard multigradings
      * "multigradedPolynomialRing(ZZ)" -- see multigradedPolynomialRing,
        -- produces polynomial rings with standard
        multigradings
      * "partialRegularities(ChainComplex)" -- see partialRegularities,
        -- calculates Castelnuovo-Mumford regularity in
        each component of a multigrading
      * "partialRegularities(Module)" -- see partialRegularities,
        -- calculates Castelnuovo-Mumford regularity in
        each component of a multigrading
      * "regularityBound(Module)" -- see regularityBound,
        -- bounds the multigraded regularity of a module
      * "supportOfTor(ChainComplex)" -- see supportOfTor,
        -- computes multidegrees in the support of Tor_i(M,k), where k is the
        residue field
      * "supportOfTor(Module)" -- see supportOfTor, --
        computes multidegrees in the support of Tor_i(M,k), where k is the
        residue field
  * Symbols
      * "Inner" -- see findRegion, -- finds minimal
        multidegree(s) in a given region where an ideal or module satisfies a
        Boolean function
      * "Outer" -- see findRegion, -- finds minimal
        multidegree(s) in a given region where an ideal or module satisfies a
        Boolean function
      * "IrrelevantIdeal" -- see isQuasiLinear, -- checks
        whether degrees in the resolution of a truncation are at most those of
        the irrelevant ideal

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

The object LinearTruncations, is a package (Macaulay2Doc).

multigradedPolynomialRing -- produces polynomial rings with standard multigradings
**********************************************************************************

Synopsis
========

  * Usage:
        multigradedPolynomialRing L
        multigradedPolynomialRing n
  * Inputs:
      * L, a list (Macaulay2Doc), entries 1 less than the desired
        number of variables for each multidegree
      * n, an integer (Macaulay2Doc), the rank of the grading, in the
        case with 2 variables for each multidegree
  * Optional inputs (Macaulay2Doc),:
      * CoefficientField => a ring (Macaulay2Doc), default value
        ZZ/32003, the coefficient field
      * Variables => a string (Macaulay2Doc), default value "x",
        name to use for indexed variables
      * Standard => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a polynomial ring (Macaulay2Doc), a multigraded
        polynomial ring

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

Given a list L, this function gives a $\ZZ^r$-graded polynomial ring (where $r$
is the length of L) containing L_i+1 variables of multidegree equal to the i-th
basis vector of $\ZZ^r$, i.e. the coordinate ring of the product of projective
spaces with dimensions the entries of L.  Given an integer n it returns the
coordinate ring of a product of n copies of $\PP^1$.

+-----------------------------------------------------------------------------+
|i1 : S = multigradedPolynomialRing({1,3,4})                                  |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : gens S                                                                  |
|                                                                             |
|o2 = {x   , x   , x   , x   , x   , x   , x   , x   , x   , x   , x   }      |
|       0,0   0,1   1,0   1,1   1,2   1,3   2,0   2,1   2,2   2,3   2,4       |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : degrees S                                                               |
|                                                                             |
|o3 = {{1, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 1, 0}, {0, 1, 0}, {0, 1, 0}, {0,  |
|     ------------------------------------------------------------------------|
|     0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}, {0, 0, 1}}                      |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : gens multigradedPolynomialRing 4                                        |
|                                                                             |
|o4 = {x   , x   , x   , x   , x   , x   , x   , x   }                        |
|       0,0   0,1   1,0   1,1   2,0   2,1   3,0   3,1                         |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

By default the output will be a ring over ZZ/32003 in variables of the form
x_(i,j).  The coefficients can be changed using the option CoefficientField and
the variable name with Variables (which takes a string).  Setting the option
Standard to false will produce variables with no indices, starting at a.

+-----------------------------------------------------------------------------+
|i5 : multigradedPolynomialRing({1,2},CoefficientField => ZZ/5,Variables=>"y")|
|                                                                             |
|     ZZ                                                                      |
|o5 = --[y   ..y   , y   ..y   ]                                              |
|      5  0,0   0,1   1,0   1,2                                               |
|                                                                             |
|o5 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i6 : multigradedPolynomialRing(3,Standard=>false)                            |
|                                                                             |
|       ZZ                                                                    |
|o6 = -----[a..f]                                                             |
|     32003                                                                   |
|                                                                             |
|o6 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+

Caveat
======

The output of multigradedPolynomialRing is not compatible with some functions
from the package TateOnProducts, such as
cohomologyHashTable (TateOnProducts). Use
productOfProjectiveSpaces (TateOnProducts), instead.

See also
========

  * productOfProjectiveSpaces (TateOnProducts),
    -- Cox ring of a product of projective spaces and it Koszul dual exterior
    algebra
  * irrelevantIdeal -- gives the irrelevant ideal of
    the coordinate ring of a product of projective spaces

Ways to use multigradedPolynomialRing :
=======================================

  * "multigradedPolynomialRing(List)"
  * "multigradedPolynomialRing(ZZ)"

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

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

irrelevantIdeal -- gives the irrelevant ideal of the coordinate ring of a product of projective spaces
******************************************************************************************************

Synopsis
========

  * Usage:
        irrelevantIdeal R
  * Inputs:
      * R, a ring (Macaulay2Doc), coordinate ring of a product of
        projective spaces
  * Outputs:
      * an ideal (Macaulay2Doc), irrelevant ideal in R

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

Given the coordinate ring of a product of projective spaces, this function
produces the irrelevant ideal (in the sense of toric geometry) by listing the
unique degrees of generators of R, creating an ideal from the generators of
each degree, and intersecting them.

+-----------------------------------------------------------------------------+
|i1 : R = multigradedPolynomialRing {1,2}                                     |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : irrelevantIdeal R                                                       |
|                                                                             |
|o2 = ideal (x   x   , x   x   , x   x   , x   x   , x   x   , x   x   )      |
|             0,1 1,2   0,0 1,2   0,1 1,1   0,0 1,1   0,1 1,0   0,0 1,0       |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : R = multigradedPolynomialRing 3                                         |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : irrelevantIdeal R                                                       |
|                                                                             |
|o4 = ideal (x   x   x   , x   x   x   , x   x   x   , x   x   x   ,          |
|             0,1 1,1 2,1   0,0 1,1 2,1   0,1 1,0 2,1   0,0 1,0 2,1           |
|     ------------------------------------------------------------------------|
|     x   x   x   , x   x   x   , x   x   x   , x   x   x   )                 |
|      0,1 1,1 2,0   0,0 1,1 2,0   0,1 1,0 2,0   0,0 1,0 2,0                  |
|                                                                             |
|o4 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+

Caveat
======

This function will not give the correct irrelevant ideal for the Cox ring of a
toric variety that is not a product of projective spaces. Use the package
NormalToricVarieties, instead.

See also
========

  * multigradedPolynomialRing -- produces
    polynomial rings with standard multigradings

Ways to use irrelevantIdeal :
=============================

  * "irrelevantIdeal(Ring)"

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

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

diagonalMultidegrees -- t-tuples of non-negative integers with sum equal to d
*****************************************************************************

Synopsis
========

  * Usage:
        diagonalMultidegrees(d,t)
        diagonalMultidegrees(d,L)
  * Inputs:
      * d, an integer (Macaulay2Doc), the (non-negative) sum of the
        tuples
      * t, an integer (Macaulay2Doc), the length of the tuples
      * L, a list (Macaulay2Doc), the maximum value for each
        coordinate
  * Outputs:
      * a list (Macaulay2Doc), containing lists of t integers each

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

Given numbers d and t, this function gives all lists of t non-negative integers
where the sum of each list is equal to d. If the second input is a list L, the
tuples have the same length as L and are constrained to have i-th entry at most
1+L_i.

+-----------------------------------------------------+
|i1 : t = 2                                           |
|                                                     |
|o1 = 2                                               |
+-----------------------------------------------------+
|i2 : d = 5                                           |
|                                                     |
|o2 = 5                                               |
+-----------------------------------------------------+
|i3 : diagonalMultidegrees(d,t)                       |
|                                                     |
|o3 = {{0, 5}, {1, 4}, {2, 3}, {3, 2}, {4, 1}, {5, 0}}|
|                                                     |
|o3 : List                                            |
+-----------------------------------------------------+
|i4 : diagonalMultidegrees(d, {0,1,2})                |
|                                                     |
|o4 = {{0, 2, 3}, {1, 1, 3}, {1, 2, 2}}               |
|                                                     |
|o4 : List                                            |
+-----------------------------------------------------+

See also
========

  * basis(ZZ,Module) (Macaulay2Doc) -- basis or generating set of
    all or part of a ring, ideal or module

Ways to use diagonalMultidegrees :
==================================

  * "diagonalMultidegrees(ZZ,List)"
  * "diagonalMultidegrees(ZZ,ZZ)"

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

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

findMins -- calculates the minimal elements of a subset of ZZ^r
***************************************************************

Synopsis
========

  * Usage:
        findMins L
  * Inputs:
      * L, a list (Macaulay2Doc), subset of $\ZZ^r$
  * Outputs:
      * a list (Macaulay2Doc), minimal elements

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

Given a list L of elements in $\ZZ^r$, this function will return the minimal
elements of L under the partial order where $c\leq d$ if and only if $c_i\leq
d_i$ for all $1\leq i\leq r$.

+-------------------------------------+
|i1 : L = {{1,2},{3,1},{3,2},{1,4}}   |
|                                     |
|o1 = {{1, 2}, {3, 1}, {3, 2}, {1, 4}}|
|                                     |
|o1 : List                            |
+-------------------------------------+
|i2 : findMins L                      |
|                                     |
|o2 = {{1, 2}, {3, 1}}                |
|                                     |
|o2 : List                            |
+-------------------------------------+

The algorithm constructs a monomial ideal by using the elements of the list as
exponents.  Such an ideal can also be given directly.

See also
========

  * findRegion -- finds minimal multidegree(s) in a given
    region where an ideal or module satisfies a Boolean function

Ways to use findMins :
======================

  * "findMins(Ideal)"
  * "findMins(List)"

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

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

findRegion -- finds minimal multidegree(s) in a given region where an ideal or module satisfies a Boolean function
******************************************************************************************************************

Synopsis
========

  * Usage:
        findRegion({L1,L2},M,f)
  * Inputs:
      * L1, a list (Macaulay2Doc), the minimum multidegree to check
      * L2, a list (Macaulay2Doc), the maximum multidegree to check
      * M, a module (Macaulay2Doc), or an ideal (Macaulay2Doc),
      * f, a function (Macaulay2Doc), a function that takes a
        List and an Ideal or Module and returns a Boolean value
  * Outputs:
      * a list (Macaulay2Doc), minimal multidegrees

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

$M$ should be an ideal or a module over a $\ZZ^r$-graded ring and f a function
so that f(d,M) is a Boolean value for d in $\ZZ^r$ and f(d,M) implies f(d+e,M)
for e in $\NN^r$. Given a list {L1, L2}, this function will return the minimal
multidegrees d between L1 and L2 satisfying f(d,M).

+-------------------------------------------+
|i1 : S = ZZ/101[x,y,Degrees=>{{1,0},{0,1}}]|
|                                           |
|o1 = S                                     |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : I = ideal(x*y^2,x^3*y)                |
|                                           |
|               2   3                       |
|o2 = ideal (x*y , x y)                     |
|                                           |
|o2 : Ideal of S                            |
+-------------------------------------------+
|i3 : M = S^1/I                             |
|                                           |
|o3 = cokernel | xy2 x3y |                  |
|                                           |
|                            1              |
|o3 : S-module, quotient of S               |
+-------------------------------------------+
|i4 : f = (d,M) -> truncate(d,M)==0         |
|                                           |
|o4 = f                                     |
|                                           |
|o4 : FunctionClosure                       |
+-------------------------------------------+
|i5 : findRegion({{0,0},{4,4}},M,f)         |
|                                           |
|o5 = {{1, 2}, {3, 1}}                      |
|                                           |
|o5 : List                                  |
+-------------------------------------------+

If some degrees d are known to satisfy f(d,M), then they can be specified using
the option Inner in order to expedite the computation.  Similarly, degrees not
above those given in Outer will be assumed not to satisfy f(d,M). If f takes
options these can also be given to findRegion.

+-----------------------------------------------------------------------------+
|i6 : elapsedTime findRegion({{0,0},{4,4}},M,f)                               |
| -- 0.0347731 seconds elapsed                                                |
|                                                                             |
|o6 = {{1, 2}, {3, 1}}                                                        |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : elapsedTime findRegion({{0,0},{4,4}},M,f,Inner=>{{1,2},{3,1}},Outer=>{{1|
| -- 0.00784575 seconds elapsed                                               |
|                                                                             |
|o7 = {{1, 2}, {3, 1}}                                                        |
|                                                                             |
|o7 : List                                                                    |
|-----------------------------------------------------------------------------|
|,1}})                                                                        |
+-----------------------------------------------------------------------------+

Contributors
============

Mahrud Sayrafi contributed to the code for this function.

Caveat
======

Use the option Outer with care if f is not invariant under positive
translation.

See also
========

  * findMins -- calculates the minimal elements of a subset of
    ZZ^r
  * multigradedRegularity (VirtualResolutions), --
    computes the minimal elements of the multigraded regularity of a module
    over a multigraded ring

Ways to use findRegion :
========================

  * "findRegion(List,Ideal,Function)"
  * "findRegion(List,Module,Function)"

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

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

partialRegularities -- calculates Castelnuovo-Mumford regularity in each component of a multigrading
****************************************************************************************************

Synopsis
========

  * Usage:
        partialRegularities M
  * Inputs:
      * M, a module (Macaulay2Doc), a multigraded module
      * F, a chain complex (Macaulay2Doc), the minimal free
        resolution of a module
  * Outputs:
      * a list (Macaulay2Doc), with i-th coordinate the regularity
        in the i-th component of the grading

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

This function applies the definition of Castelnuovo-Mumford regularity to the
complex obtained by resolving the module $M$ and forgetting all but the i-th
coordinate of the twists appearing. Alternately, the minimal resolution of $M$
can be given directly.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[x_0,x_1,y_0,y_1,z_0,z_1,Degrees=>{{1,0,0},{1,0,0},{0,1,0},{0,|
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
|-----------------------------------------------------------------------------|
|1,0},{0,0,1},{0,0,1}}]                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_0*x_1*y_0*z_0^2, x_1^2*y_0^2*y_1^2*z_0^2, x_0^3*y_0*z_1,    |
|                                                                             |
|                   2   2 2 2 2   3       2             2 2 3   3 2   2       |
|o2 = ideal (x x y z , x y y z , x y z , x x y z z , x x y z , x y y z )      |
|             0 1 0 0   1 0 1 0   0 0 1   0 1 1 0 1   0 1 1 0   1 0 1 1       |
|                                                                             |
|o2 : Ideal of S                                                              |
|-----------------------------------------------------------------------------|
|x_0^2*x_1*y_1*z_0*z_1, x_0*x_1^2*y_1^2*z_0^3, x_1^3*y_0^2*y_1*z_1^2)         |
+-----------------------------------------------------------------------------+
|i3 : M = S^1/I                                                               |
|                                                                             |
|o3 = cokernel | x_0x_1y_0z_0^2 x_1^2y_0^2y_1^2z_0^2 x_0^3y_0z_1              |
|                                                                             |
|                            1                                                |
|o3 : S-module, quotient of S                                                 |
|-----------------------------------------------------------------------------|
|x_0^2x_1y_1z_0z_1 x_0x_1^2y_1^2z_0^3 x_1^3y_0^2y_1z_1^2 |                    |
+-----------------------------------------------------------------------------+
|i4 : netList supportOfTor M                                                  |
|                                                                             |
|     +---------+---------+---------+---------+---------+---------+---------+-|
|o4 = |{0, 0, 0}|         |         |         |         |         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{2, 1, 2}|{3, 1, 1}|{3, 1, 2}|{2, 4, 2}|{3, 2, 3}|{3, 3, 2}|         | |
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{4, 2, 2}|{4, 1, 3}|{3, 2, 3}|{3, 4, 2}|{3, 3, 3}|{4, 2, 4}|{6, 3, 2}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{4, 2, 3}|{4, 3, 4}|{6, 3, 3}|{5, 3, 4}|{4, 4, 4}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+-|
|-----------------------------------------------------------------------------|
|--------+---------+---------+                                                |
|        |         |         |                                                |
|--------+---------+---------+                                                |
|        |         |         |                                                |
|--------+---------+---------+                                                |
|5, 3, 3}|{4, 3, 4}|{3, 4, 4}|                                                |
|--------+---------+---------+                                                |
|        |         |         |                                                |
|--------+---------+---------+                                                |
+-----------------------------------------------------------------------------+
|i5 : partialRegularities M                                                   |
|                                                                             |
|o5 = {4, 3, 2}                                                               |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

In the bigraded case this element will always be contained in the multigraded
regularity if its total degree is at least $\operatorname{reg} M$.

Caveat
======

Changing the grading of $M$ and applying the command regularity (Macaulay2Doc),
will not yield the correct result because betti
tables in Macaulay2 do not (at least at the time of this writing) accommodate
rings with generators of degree 0.

See also
========

  * regularity (Macaulay2Doc) -- compute the
    Castelnuovo-Mumford regularity

Ways to use partialRegularities :
=================================

  * "partialRegularities(ChainComplex)"
  * "partialRegularities(Module)"

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

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

isLinearComplex -- tests whether a complex of graded modules is linear
**********************************************************************

Synopsis
========

  * Usage:
        isLinearComplex F
  * Inputs:
      * F, a chain complex (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if F is a linear
        complex, false if it is not

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

We say that a (nonzero) $\ZZ^r$-graded complex F is linear if its first nonzero
module is generated in a single multidegree and all of its maps (including the
zero maps) have degree at most 1.  For instance, if F_i is zero for $i<0$ and
F_0 is generated in degree $0\in\ZZ^r$, then F_i should be generated in
multidegrees with sum at most $i$ for $i>0$.  If F is zero then the function
returns true.

+----------------------------------------------------------+
|i1 : S = ZZ/101[x_1..x_4]                                 |
|                                                          |
|o1 = S                                                    |
|                                                          |
|o1 : PolynomialRing                                       |
+----------------------------------------------------------+
|i2 : I = ideal(x_1*x_2, x_1*x_3,x_1*x_4, x_2*x_3, x_3*x_4)|
|                                                          |
|o2 = ideal (x x , x x , x x , x x , x x )                 |
|             1 2   1 3   1 4   2 3   3 4                  |
|                                                          |
|o2 : Ideal of S                                           |
+----------------------------------------------------------+
|i3 : M = S^1/I                                            |
|                                                          |
|o3 = cokernel | x_1x_2 x_1x_3 x_1x_4 x_2x_3 x_3x_4 |      |
|                                                          |
|                            1                             |
|o3 : S-module, quotient of S                              |
+----------------------------------------------------------+
|i4 : F = res M                                            |
|                                                          |
|      1      5      6      2                              |
|o4 = S  <-- S  <-- S  <-- S  <-- 0                        |
|                                                          |
|     0      1      2      3      4                        |
|                                                          |
|o4 : ChainComplex                                         |
+----------------------------------------------------------+
|i5 : betti F                                              |
|                                                          |
|            0 1 2 3                                       |
|o5 = total: 1 5 6 2                                       |
|         0: 1 . . .                                       |
|         1: . 5 6 2                                       |
|                                                          |
|o5 : BettiTally                                           |
+----------------------------------------------------------+
|i6 : isLinearComplex F                                    |
|                                                          |
|o6 = false                                                |
+----------------------------------------------------------+
|i7 : F' = res truncate(2,M)                               |
|                                                          |
|      5      14      13      4                            |
|o7 = S  <-- S   <-- S   <-- S  <-- 0                      |
|                                                          |
|     0      1       2       3      4                      |
|                                                          |
|o7 : ChainComplex                                         |
+----------------------------------------------------------+
|i8 : betti F'                                             |
|                                                          |
|            0  1  2 3                                     |
|o8 = total: 5 14 13 4                                     |
|         2: 5 14 13 4                                     |
|                                                          |
|o8 : BettiTally                                           |
+----------------------------------------------------------+
|i9 : isLinearComplex F'                                   |
|                                                          |
|o9 = true                                                 |
+----------------------------------------------------------+

Caveat
======

It is possible for a complex to have differential matrices containing only
linear entries yet be nonlinear by the definition above.

See also
========

  * isQuasiLinear -- checks whether degrees in the
    resolution of a truncation are at most those of the irrelevant ideal

Ways to use isLinearComplex :
=============================

  * "isLinearComplex(ChainComplex)"

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

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

linearTruncations -- finds minimal multidegree(s) in a given range where the resolution of a truncated module is linear
***********************************************************************************************************************

Synopsis
========

  * Usage:
        linearTruncations(L,M)
        linearTruncations M
  * Inputs:
      * L, a list (Macaulay2Doc), containing 2 lists: minimum and
        maximum multidegrees defining range
      * M, a module (Macaulay2Doc), the module to be truncated
  * Outputs:
      * a list (Macaulay2Doc), containing multidegrees with linear
        truncations

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

Given a list {L1,L2} and a module $M$, this function truncates $M$ at each
multidegree between L1 and L2 and tests whether the minimal resolution of the
resulting module is linear.  The set of multidegrees producing linear
resolutions is invariant under positive translation, and the function returns
the minimal multidegrees in this set.  If a list L is not provided it will
search between the componentwise minimum of the degrees of the generators of
$M$ and the degree with all coordinates equal to $r+1$, where $r$ is the
regularity (Macaulay2Doc), of $M$.

+-----------------------------------------------------------------------------+
|i1 : S = multigradedPolynomialRing({2,3},Standard=>false)                    |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M = coker map(S^{{0,-3},{0,-3},{-3,0},{-3,0},{-3,0},{-3,0}},S^{{-3,-3   |
|     {{a^3,b^3,c^3, 0,0,0},{0,0,0,b^3,a^3,c^3},{-d^3,0,0,-d^3,0,0},{0,-e^3   |
|                                                                             |
|o2 = cokernel {0, 3} | a3  b3  c3  0   0   0   |                             |
|              {0, 3} | 0   0   0   b3  a3  c3  |                             |
|              {3, 0} | -d3 0   0   -d3 0   0   |                             |
|              {3, 0} | 0   -e3 0   0   -e3 0   |                             |
|              {3, 0} | 0   0   -f3 0   0   -f3 |                             |
|              {3, 0} | 0   0   0   -g3 0   0   |                             |
|                                                                             |
|                             6                                               |
|o2 : S-module, quotient of S                                                 |
|-----------------------------------------------------------------------------|
|},{-3,-3},{-3,-3},{-3,-3},{-3,-3},{-3,-3}},                                  |
|,0,0,-e^3,0},{0,0,-f^3,0,0,-f^3},{0,0,0,-g^3,0,0}})                          |
+-----------------------------------------------------------------------------+
|i3 : linearTruncations M                                                     |
|                                                                             |
|o3 = {{3, 3}}                                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : linearTruncations({{0,0},{9,9}}, M)                                     |
|                                                                             |
|o4 = {{3, 3}, {8, 2}}                                                        |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

With the default options there may be generators of the linear truncation
region not contained in the search region and thus not returned.

See also
========

  * coarseMultigradedRegularity (TateOnProducts)
    -- A truncation that has
    linear resolution
  * isLinearComplex -- tests whether a complex of
    graded modules is linear

Ways to use linearTruncations :
===============================

  * "linearTruncations(List,Module)"
  * "linearTruncations(Module)"

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

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

supportOfTor -- computes multidegrees in the support of Tor_i(M,k), where k is the residue field
************************************************************************************************

Synopsis
========

  * Usage:
        supportOfTor M
  * Inputs:
      * M, a module (Macaulay2Doc), a multigraded module
      * F, a chain complex (Macaulay2Doc), the minimal
        resolution of a module
  * Outputs:
      * L, a list (Macaulay2Doc), where L_i contains multidegrees
        for $\operatorname{Tor}_i(M,k)$

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

This function computes a minimal free resolution of the (pruned) module $M$,
reduces it by the maximal ideal, and returns a list of the unique degrees that
occur at each step.

+-----------------------------------------------------------------------------+
|i1 : S = multigradedPolynomialRing {1,2}                                     |
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : B = irrelevantIdeal S                                                   |
|                                                                             |
|o2 = ideal (x   x   , x   x   , x   x   , x   x   , x   x   , x   x   )      |
|             0,1 1,2   0,0 1,2   0,1 1,1   0,0 1,1   0,1 1,0   0,0 1,0       |
|                                                                             |
|o2 : Ideal of S                                                              |
+-----------------------------------------------------------------------------+
|i3 : M = S^1/B                                                               |
|                                                                             |
|o3 = cokernel | x_(0,1)x_(1,2) x_(0,0)x_(1,2) x_(0,1)x_(1,1) x_(0,0)x_(1,1)  |
|                                                                             |
|                            1                                                |
|o3 : S-module, quotient of S                                                 |
|-----------------------------------------------------------------------------|
|x_(0,1)x_(1,0) x_(0,0)x_(1,0) |                                              |
+-----------------------------------------------------------------------------+
|i4 : F = res prune M                                                         |
|                                                                             |
|      1      6      9      5      1                                          |
|o4 = S  <-- S  <-- S  <-- S  <-- S  <-- 0                                    |
|                                                                             |
|     0      1      2      3      4      5                                    |
|                                                                             |
|o4 : ChainComplex                                                            |
+-----------------------------------------------------------------------------+
|i5 : multigraded betti F                                                     |
|                                                                             |
|        0   1         2          3    4                                      |
|o5 = 0: 1   .         .          .    .                                      |
|     2: . 6ab         .          .    .                                      |
|     3: .   . 3a2b+6ab2          .    .                                      |
|     4: .   .         . 3a2b2+2ab3    .                                      |
|     5: .   .         .          . a2b3                                      |
|                                                                             |
|o5 : MultigradedBettiTally                                                   |
+-----------------------------------------------------------------------------+
|i6 : supportOfTor M                                                          |
|                                                                             |
|o6 = {{{0, 0}}, {{1, 1}}, {{2, 1}, {1, 2}}, {{2, 2}, {1, 3}}, {{2, 3}}}      |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : netList supportOfTor M                                                  |
|                                                                             |
|     +------+------+                                                         |
|o7 = |{0, 0}|      |                                                         |
|     +------+------+                                                         |
|     |{1, 1}|      |                                                         |
|     +------+------+                                                         |
|     |{2, 1}|{1, 2}|                                                         |
|     +------+------+                                                         |
|     |{2, 2}|{1, 3}|                                                         |
|     +------+------+                                                         |
|     |{2, 3}|      |                                                         |
|     +------+------+                                                         |
+-----------------------------------------------------------------------------+

Alternately, the minimal free resolution can be given directly.

+---------------------------+
|i8 : netList supportOfTor F|
|                           |
|     +------+------+       |
|o8 = |{0, 0}|      |       |
|     +------+------+       |
|     |{1, 1}|      |       |
|     +------+------+       |
|     |{2, 1}|{1, 2}|       |
|     +------+------+       |
|     |{2, 2}|{1, 3}|       |
|     +------+------+       |
|     |{2, 3}|      |       |
|     +------+------+       |
+---------------------------+

See also
========

  * multigraded(BettiTally) (Macaulay2Doc) -- convert a
    Betti tally into a multigraded Betti tally

Ways to use supportOfTor :
==========================

  * "supportOfTor(ChainComplex)"
  * "supportOfTor(Module)"

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

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

linearTruncationsBound -- bounds the region where truncations of a module have linear resolutions
*************************************************************************************************

Synopsis
========

  * Usage:
        linearTruncationsBound M
  * Inputs:
      * M, a module (Macaulay2Doc), a multigraded module
  * Outputs:
      * a list (Macaulay2Doc), containing multidegrees where the
        truncation of M will have a linear resolution

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

Using only the multigraded betti numbers of a $\ZZ^r$-graded module $M$, this
function identifies multidegrees at which the truncation of $M$ will have a
linear minimal resolution (i.e. where the resolution will satisfy
isLinearComplex).

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[x_0,x_1,y_0,y_1,z_0,z_1,Degrees=>{{1,0,0},{1,0,0},{0,1,0},{0,|
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
|-----------------------------------------------------------------------------|
|1,0},{0,0,1},{0,0,1}}]                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_0*x_1*y_0*z_0^2, x_1^2*y_0^2*y_1^2*z_0^2, x_0^3*y_0*z_1,    |
|                                                                             |
|                   2   2 2 2 2   3       2             2 2 3   3 2   2       |
|o2 = ideal (x x y z , x y y z , x y z , x x y z z , x x y z , x y y z )      |
|             0 1 0 0   1 0 1 0   0 0 1   0 1 1 0 1   0 1 1 0   1 0 1 1       |
|                                                                             |
|o2 : Ideal of S                                                              |
|-----------------------------------------------------------------------------|
|x_0^2*x_1*y_1*z_0*z_1, x_0*x_1^2*y_1^2*z_0^3, x_1^3*y_0^2*y_1*z_1^2)         |
+-----------------------------------------------------------------------------+
|i3 : M = S^1/I                                                               |
|                                                                             |
|o3 = cokernel | x_0x_1y_0z_0^2 x_1^2y_0^2y_1^2z_0^2 x_0^3y_0z_1              |
|                                                                             |
|                            1                                                |
|o3 : S-module, quotient of S                                                 |
|-----------------------------------------------------------------------------|
|x_0^2x_1y_1z_0z_1 x_0x_1^2y_1^2z_0^3 x_1^3y_0^2y_1z_1^2 |                    |
+-----------------------------------------------------------------------------+
|i4 : L = linearTruncationsBound M                                            |
|                                                                             |
|o4 = {{4, 3, 3}, {4, 4, 2}}                                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : apply(L, d -> isLinearComplex res prune truncate(d,M))                  |
|                                                                             |
|o5 = {true, true}                                                            |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

The output is a list of the minimal multidegrees $d$ such that the sum of the
positive coordinates of $b-d$ is at most $i$ for all degrees $b$ appearing in
the i-th step of the resolution of $M$.

+--------------------------------------------------------+
|i6 : elapsedTime linearTruncations({{2,2,2},{4,4,4}}, M)|
| -- 4.38466 seconds elapsed                             |
|                                                        |
|o6 = {{4, 3, 3}, {4, 4, 2}}                             |
|                                                        |
|o6 : List                                               |
+--------------------------------------------------------+
|i7 : elapsedTime linearTruncationsBound M               |
| -- 0.0241154 seconds elapsed                           |
|                                                        |
|o7 = {{4, 3, 3}, {4, 4, 2}}                             |
|                                                        |
|o7 : List                                               |
+--------------------------------------------------------+

Caveat
======

In general linearTruncationsBound will not find the minimal degrees where $M$
has a linear resolution but will be faster than repeatedly truncating $M$.

See also
========

  * isLinearComplex -- tests whether a complex of
    graded modules is linear
  * linearTruncations -- finds minimal multidegree(s)
    in a given range where the resolution of a truncated module is linear

Ways to use linearTruncationsBound :
====================================

  * "linearTruncationsBound(Module)"

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

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

regularityBound -- bounds the multigraded regularity of a module
****************************************************************

Synopsis
========

  * Usage:
        regularityBound M
  * Inputs:
      * M, a module (Macaulay2Doc), a multigraded module with no
        $H^0_B$ or $H^1_B$
  * Outputs:
      * a list (Macaulay2Doc), containing multidegrees in the
        regularity of M

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

Using only the multigraded betti numbers of a $\ZZ^r$-graded module $M$, this
function identifies a subset of the multigraded regularity of a module $M$ over
the coordinate ring $S$ of a product of projective spaces, in the sense of
Maclagan and Smith.  It assumes that the local cohomology groups $H^0_B(M)$ and
$H^1_B(M)$ vanish, where $B$ is the irrelevant ideal of $S$.

+--------------------------------------------+
|i1 : (S,E) = productOfProjectiveSpaces {1,2}|
|                                            |
|o1 = (S, E)                                 |
|                                            |
|o1 : Sequence                               |
+--------------------------------------------+
|i2 : I = ideal(x_(0,0)*x_(1,0),x_(1,1)^3)   |
|                                            |
|                       3                    |
|o2 = ideal (x   x   , x   )                 |
|             0,0 1,0   1,1                  |
|                                            |
|o2 : Ideal of S                             |
+--------------------------------------------+
|i3 : M = S^1/I                              |
|                                            |
|o3 = cokernel | x_(0,0)x_(1,0) x_(1,1)^3 |  |
|                                            |
|                            1               |
|o3 : S-module, quotient of S                |
+--------------------------------------------+
|i4 : regularityBound M                      |
|                                            |
|o4 = {{0, 2}}                               |
|                                            |
|o4 : List                                   |
+--------------------------------------------+
|i5 : needsPackage "VirtualResolutions"      |
|                                            |
|o5 = VirtualResolutions                     |
|                                            |
|o5 : Package                                |
+--------------------------------------------+
|i6 : multigradedRegularity(S,M)             |
|                                            |
|o6 = {{0, 2}}                               |
|                                            |
|o6 : List                                   |
+--------------------------------------------+

The output is often but not always {partialRegularities M}.

Caveat
======

In general regularityBound will not give the minimal elements of
$\operatorname{reg} M$ but will be faster than computing cohomology.

See also
========

  * partialRegularities -- calculates
    Castelnuovo-Mumford regularity in each component of a multigrading
  * isQuasiLinear -- checks whether degrees in the
    resolution of a truncation are at most those of the irrelevant ideal
  * multigradedRegularity (VirtualResolutions), --
    computes the minimal elements of the multigraded regularity of a module
    over a multigraded ring

Ways to use regularityBound :
=============================

  * "regularityBound(Module)"

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

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

isQuasiLinear -- checks whether degrees in the resolution of a truncation are at most those of the irrelevant ideal
*******************************************************************************************************************

Synopsis
========

  * Usage:
        isQuasiLinear(d,M)
  * Inputs:
      * d, a list (Macaulay2Doc), a multidegree at which to
        truncate the module
      * M, a module (Macaulay2Doc), a module over a multigraded
        ring $S$
  * Optional inputs (Macaulay2Doc),:
      * IrrelevantIdeal => an ideal (Macaulay2Doc), default value
        null, the irrelevant ideal of $S$
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This function truncates the module $M$ at degree $d$ and compares the twists
appearing in its resolution with those appearing in the resolution of $S/B$,
where $S$ is the ring of $M$ and $B$ the irrelevant ideal.  If for some $i$ the
i-th step of the resolution contains a summand $S(-c-d)$ such that no summand
of the i-th step of the resolution of $S/B$ has generator of degree greater
than $c$ then the output will be false.

If the option IrrelevantIdeal is not specified it will be calculated assuming
that $S$ is the coordinate ring of a product of projective spaces.

+-----------------------------------------------------------------------------+
|i1 : S = ZZ/101[x_0,x_1,y_0,y_1,z_0,z_1,Degrees=>{{1,0,0},{1,0,0},{0,1,0},{0,|
|                                                                             |
|o1 = S                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
|-----------------------------------------------------------------------------|
|1,0},{0,0,1},{0,0,1}}]                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_0*x_1*y_0*z_0^2, x_1^2*y_0^2*y_1^2*z_0^2, x_0^3*y_0*z_1,    |
|                                                                             |
|                   2   2 2 2 2   3       2             2 2 3   3 2   2       |
|o2 = ideal (x x y z , x y y z , x y z , x x y z z , x x y z , x y y z )      |
|             0 1 0 0   1 0 1 0   0 0 1   0 1 1 0 1   0 1 1 0   1 0 1 1       |
|                                                                             |
|o2 : Ideal of S                                                              |
|-----------------------------------------------------------------------------|
|x_0^2*x_1*y_1*z_0*z_1, x_0*x_1^2*y_1^2*z_0^3, x_1^3*y_0^2*y_1*z_1^2)         |
+-----------------------------------------------------------------------------+
|i3 : M = S^1/I                                                               |
|                                                                             |
|o3 = cokernel | x_0x_1y_0z_0^2 x_1^2y_0^2y_1^2z_0^2 x_0^3y_0z_1              |
|                                                                             |
|                            1                                                |
|o3 : S-module, quotient of S                                                 |
|-----------------------------------------------------------------------------|
|x_0^2x_1y_1z_0z_1 x_0x_1^2y_1^2z_0^3 x_1^3y_0^2y_1z_1^2 |                    |
+-----------------------------------------------------------------------------+
|i4 : d = {4,3,2}                                                             |
|                                                                             |
|o4 = {4, 3, 2}                                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : isLinearComplex res prune truncate({4,3,2},M)                           |
|                                                                             |
|o5 = false                                                                   |
+-----------------------------------------------------------------------------+
|i6 : isQuasiLinear(d,M)                                                      |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

The condition comes from Theorem 2.9 in Berkesch, Erman, and Smith's paper
"Virtual Resolutions for a Product of Projective Spaces." The ChainComplex and
BettiTally usages take the resolution of the truncation (or some other virtual
resolution) directly.

Caveat
======

If the resolution of the truncation is longer than the resolution of $S/B$ then
isQuasiLinear will return false.

See also
========

  * irrelevantIdeal -- gives the irrelevant ideal of
    the coordinate ring of a product of projective spaces
  * truncate (Macaulay2Doc)

Ways to use isQuasiLinear :
===========================

  * "isQuasiLinear(BettiTally)"
  * "isQuasiLinear(ChainComplex)"
  * "isQuasiLinear(List,Module)"

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

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

compMin -- takes componentwise minimum or maximum of a list of lists
********************************************************************

Synopsis
========

  * Usage:
        compMin L
        compMin(L1,L2)
        compMax L
        compMax(L1,L2)
  * Inputs:
      * L, a list (Macaulay2Doc), containing lists of the same
        length
  * Outputs:
      * a list (Macaulay2Doc), with the same length as those in L

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

The functions compMin and compMax take the minimum and maximum, respectively,
of a list of lists of integers (or elements of another partially ordered set)
by considering each component separately.

+---------------------------------------+
|i1 : L = {{3,4,1},{5,8,1},{10,2,7}}    |
|                                       |
|o1 = {{3, 4, 1}, {5, 8, 1}, {10, 2, 7}}|
|                                       |
|o1 : List                              |
+---------------------------------------+
|i2 : compMin L                         |
|                                       |
|o2 = {3, 2, 1}                         |
|                                       |
|o2 : List                              |
+---------------------------------------+
|i3 : compMax L                         |
|                                       |
|o3 = {10, 8, 7}                        |
|                                       |
|o3 : List                              |
+---------------------------------------+

The usage compMin(L1,L2) gives the same output as compMin {L1,L2}.

Caveat
======

If L is empty it will be returned unchanged.

Ways to use compMin :
=====================

  * "compMin(List)"
  * "compMin(List,List)"

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

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