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

EliminationMatrices -- resultants
*********************************

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

EliminationMatrices is a package for elimination theory, emphasizing universal
formulas, in particular, resultant computations.

The package contains an implementation for computing determinant of free graded
complexes, called detComplex, with several derived methods:
listDetComplex, mapsComplex, and
minorsComplex. This provides a method for producing
universal formulas for any family of schemes, just by combining the
resolution(Ideal) (OldChainComplexes), method with
detComplex. In Section 2 determinants of free resolutions are
treated, as well as a few examples. We recommend to see [Dem84, Jou95, GKZ94,
Bus06] for more details on determinants of complexes in elimination theory.

The package also provides a method eliminationMatrix,
for computing matrices and formulas for different resultants applicable on
different families of polynomials, such as the Macaulay resultant (Macaulay)
for generic homogeneous polynomials; the residual resultant ('ciResidual' and
'CM2Residual') for generic polynomials having a non empty base locus scheme;
the determinantal resultant ('determinantal') for generic polynomial matrices
of a given generic rank. For the theory behind those resultants, the reader can
refer to [Mac02, Jou91, Cha93, GKZ94, Jou97, CLO98, BEM00, BEM01, Bus01b,
Bus06, Bus04].

The goal of this package is to provide universal formulas for elimination. The
main advantage of this approach consists in the fact that one can provide
formulas for some families of polynomials just by taking determinant to a free
resolution. A direct consequence of a universal formula is that it is preserved
by base change, in particular it commutes with specialization. A deep study of
universal formulas for the image of a map of schemes can be seen in [EH00].

Bibliography:

[BBD12] Nicolás Botbol, Laurent Busé and Manuel Dubinsky.  PDF (see
http://mate.dm.uba.ar/~nbotbol/pdfs/ResultantsM2.pdf ). Package for elimination
theory in Macaulay2 (2012).

[BEM00] Laurent Busé, Mohamed Elkadi and Bernard Mourrain, Generalized
resultants over unirational algebraic varieties, J. Symbolic Comput. 29 (2000),
no. 4-5, 515–526.

[BEM01] Laurent Busé, Mohamed Elkadi and Bernard Mourrain, Resultant over the
residual of a complete intersection, Journal of Pure and Applied Algebra 164
(2001), no. 1-2, 35–57.

[Bus01a] Laurent Busé, Residual resultant over the projective plane and the
implicitization problem, International Symposium on Symbolic and Algebraic
Computing (ISSAC), ACM, (2001). Please, see the errata.pdf attached file., pp.
48–55.

[Bus04] Laurent Busé, Resultants of determinantal varieties, J.Pure Appl.
Algebra193 (2004), no.1-3, 71–97.

[Bus06] Laurent Busé, Elimination theory in codimension one and applications,
(2006).

[Cha93] Marc Chardin, The resultant via a Koszul complex, Computational
algebraic geometry (1992), Progr. Math, vol. 109, Birkhäuser Boston, Boston,
MA, pp. 29–39.

[CLO98] David Cox, John Little and Donal O’Shea, Using algebraic geometry,
Graduate Texts in Mathematics, vol. 185, Springer-Verlag, New York, (1998).

[Dem94] Michel Demazure, Une définition constructive du resultant, Centre de
Mathématiques de l’Ecole Polytechnique 2 (1984), no. Notes informelles du
calcul formel 1984-1994, 0–23.

[EH00] David Eisenbud and Joe Harris, The geometry of schemes., Graduate Texts
in Mathematics. 197. New York, NY: Springer. x, 294 p., (2000).

[GKZ94] Israel M. Gel′fand, Mikhail M. Kapranov and Andrei V. Zelevinsky,
Discriminants, resultants, and multidimensional determinants, (1994).
Mathematics: Theory & Applications, Birkh ̈auser Boston Inc, Boston, MA.

[Jou91] Jean-Pierre Jouanolou, Le formalisme du résultant, Adv. Math 90 (1991),
no. 2, 117–263.

[Jou97] Jean-Pierre Jouanolou, Formes d’inertie et résultant: un formulaire,
Adv. Math. 126 (1997), no. 2, 119–250.

[Mac02] Francis S. Macaulay, Some formulae in elimination, Proc. London Math.
Soc. 33 (1902), no. 1, 3–27.

Authors
=======

  * Nicolás Botbol (see http://mate.dm.uba.ar/~nbotbol/ ) <nbotbol@dm.uba.ar>
  * Laurent Busé (see http://www-sop.inria.fr/members/Laurent.Buse/ )
    <Laurent.Buse@inria.fr>
  * Manuel Dubinsky <manudubinsky@gmail.com>

Version
=======

This documentation describes version 1.4 of EliminationMatrices, released 13
February 2012.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{EliminationMatricesSource,                                            |
|  title = {{EliminationMatrices: resultants. Version~1.4}},                 |
|  author = {Nicol{\'a}s Botbol and Laurent Bus{\'e} and Manuel Dubinsky},   |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * bezoutianMatrix -- returns a matrix associated
        to generalized resultants
      * ciResDeg -- compute a regularity index and partial
        degrees of the residual resultant over a complete intersection
      * ciResDegGH -- compute a regularity index used for
        the residual resultant over a complete intersection
      * degHomPolMap -- return the base of monomials in a
        subset of variables, and the matrix of coefficients of a morphism of
        free modules f:R(d1)+...+R(dn)->R_d with respect to these variables
      * detComplex -- This function calculates the
        determinant of a graded Complex with respect to a subset of the
        variables of the polynomial ring in a fixed degree.
      * detResDeg -- compute a regularity index and partial
        degrees of the determinantal resultant
      * eliminationMatrix -- returns a matrix that
        represents the image of the map
      * listDetComplex -- This function calculates the
        list with the determinants of some minors of the maps of a graded
        Complex with respect to a subset of the variables of the polynomial
        ring in a fixed degree.
      * macaulayFormula -- returns two matrices such
        that the ratio of their determinants is the Macaulay resultant
      * mapsComplex -- This function calculates the maps of
        a graded Complex with respect to a subset of the variables of the
        polynomial ring in a fixed degree.
      * maxCol -- Returns a submatrix form by a maximal set of
        linear independent columns.
      * maxMinor -- Returns a maximal minor of the matrix of
        full rank.
      * minorsComplex -- calculate some minors of the
        maps of a graded Complex in a subset of variables and fixed degree
      * regularityVar -- computes the Castelnuovo-Mumford
        regularity of homogeneous ideals in terms of Betti numbers, with
        respect to some of the variables of the ring
  * Methods
      * "bezoutianMatrix(List,Matrix)" -- see bezoutianMatrix,
        -- returns a matrix associated to generalized
        resultants
      * "degHomPolMap(Matrix,List,List,ZZ)" -- see degHomPolMap,
        -- return the base of monomials in a subset of variables,
        and the matrix of coefficients of a morphism of free modules
        f:R(d1)+...+R(dn)->R_d with respect to these variables
      * "degHomPolMap(Matrix,List,ZZ)" -- see degHomPolMap,
        -- return the base of monomials in a subset of variables, and the
        matrix of coefficients of a morphism of free modules
        f:R(d1)+...+R(dn)->R_d with respect to these variables
      * "detComplex(ZZ,List,Complex)" -- see detComplex, --
        This function calculates the determinant of a graded Complex with
        respect to a subset of the variables of the polynomial ring in a fixed
        degree.
      * eliminationMatrix(List,Matrix)
        -- returns a matrix associated to
        the Macaulay resultant
      * eliminationMatrix(List,Matrix,Matrix)
        -- returns a matrix
        corresponding to a residual resultant
      * eliminationMatrix(ZZ,List,Matrix)
        -- returns a matrix
        corresponding to the determinantal resultant, in particular the
        Macaulay resultant
      * "listDetComplex(ZZ,List,Complex)" -- see listDetComplex,
        -- This function calculates the list with the
        determinants of some minors of the maps of a graded Complex with
        respect to a subset of the variables of the polynomial ring in a fixed
        degree.
      * "macaulayFormula(List,Matrix)" -- see macaulayFormula,
        -- returns two matrices such that the ratio of their
        determinants is the Macaulay resultant
      * "mapsComplex(ZZ,List,Complex)" -- see mapsComplex,
        -- This function calculates the maps of a graded Complex with respect
        to a subset of the variables of the polynomial ring in a fixed degree.
      * "maxCol(Matrix)" -- see maxCol, -- Returns a submatrix
        form by a maximal set of linear independent columns.
      * "maxMinor(Matrix)" -- see maxMinor, -- Returns a
        maximal minor of the matrix of full rank.
      * "minorsComplex(ZZ,List,Complex)" -- see minorsComplex,
        -- calculate some minors of the maps of a graded Complex
        in a subset of variables and fixed degree
      * "regularityVar(List,Ideal)" -- see regularityVar,
        -- computes the Castelnuovo-Mumford regularity of homogeneous ideals in
        terms of Betti numbers, with respect to some of the variables of the
        ring
  * Symbols
      * byResolution -- Strategy for eliminationMatrix.
      * ciResidual -- Strategy for eliminationMatrix.
      * CM2Residual -- Strategy for eliminationMatrix.
      * determinantal -- Strategy for eliminationMatrix.
      * Exact -- Strategy for functions that uses rank
        computation.
      * Macaulay -- Strategy for eliminationMatrix.
      * Numeric -- Strategy for functions that uses rank
        computation.
      * Sylvester -- Strategy for eliminationMatrix.

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

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

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

The source of this document is in EliminationMatrices.m2:843:0.

bezoutianMatrix -- returns a matrix associated to generalized resultants
************************************************************************

  * Usage:
        bezoutianMatrix(v, m)
  * Inputs:
      * v, a list (Macaulay2Doc),  a list of n-1 variables to be
        eliminated form the fi's
      * m, a matrix (Macaulay2Doc),  a single row matrix with
        (affine) polynomials $f_1,...,f_n$
  * Outputs:
      * a matrix (Macaulay2Doc), an elimination matrix

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

Let R be a polynomial ring in two groups of variables $X_1,...,X_{n-1}$ and
$a_1,...,a_s$. The variables $a_1,...,a_s$ are seen as parameters and the
variables $X_1,...,X_{n-1}$ are to be eliminated. Being given a row matrix
$f_1,...,f_n$ where each  $f_i$ is a polynomial in $X_1,...,X_{n-1}$ and
$a_1,...,a_s$, this function returns an elimination matrix that only depends on
the parameters $a_1,...,a_s$ and whose maximal nonzero minor yields a multiple
of the generalized resultant associated to $f_1,...,f_n$
+---------------------------------+
|i1 : R=QQ[a..i,x,y]              |
|                                 |
|o1 = R                           |
|                                 |
|o1 : PolynomialRing              |
+---------------------------------+
|i2 : f1 = a*x+b*y+c              |
|                                 |
|o2 = a*x + b*y + c               |
|                                 |
|o2 : R                           |
+---------------------------------+
|i3 : f2 = d*x+e*y+f              |
|                                 |
|o3 = d*x + e*y + f               |
|                                 |
|o3 : R                           |
+---------------------------------+
|i4 : f3 = g*x+h*y+i              |
|                                 |
|o4 = g*x + h*y + i               |
|                                 |
|o4 : R                           |
+---------------------------------+
|i5 : M = matrix{{f1,f2,f3}}      |
|                                 |
|o5 = | ax+by+c dx+ey+f gx+hy+i | |
|                                 |
|             1      3            |
|o5 : Matrix R  <-- R             |
+---------------------------------+
|i6 : l = {x,y}                   |
|                                 |
|o6 = {x, y}                      |
|                                 |
|o6 : List                        |
+---------------------------------+
|i7 : MR = bezoutianMatrix (l,M)  |
|                                 |
|o7 = | -ceg+bfg+cdh-afh-bdi+aei ||
|                                 |
|             1      1            |
|o7 : Matrix R  <-- R             |
+---------------------------------+

See also
========

  * eliminationMatrix -- returns a matrix that
    represents the image of the map
  * macaulayFormula -- returns two matrices such that
    the ratio of their determinants is the Macaulay resultant

Ways to use bezoutianMatrix:
============================

  * "bezoutianMatrix(List,Matrix)"

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

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

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

The source of this document is in EliminationMatrices.m2:1228:0.

byResolution -- Strategy for eliminationMatrix.
***********************************************

  * Usage:
        eliminationMatrix(..., Strategy => byResolution)
  * Consequences:
      * This function computes the matrix of the first application in the
        resolution of (I:J) given by
      * freeResolution (Complexes) -- compute a free
        resolution of a module or ideal
      * in degree
      * regularity (Macaulay2Doc) -- compute the
        Castelnuovo-Mumford regularity

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

The object byResolution, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1609:0.

ciResDeg -- compute a regularity index and partial degrees of the residual resultant over a complete intersection
*****************************************************************************************************************

  * Usage:
        ciResDeg(List, List)
  * Inputs:
      * d, a list (Macaulay2Doc), a list of element in the ambient
        ring corresponding to the degrees of a system of polynomials
        $d_0,...,d_n$
      * k, a list (Macaulay2Doc), a list of element in the ambient
        ring corresponding to the degrees of a complete intersection
        $k_1,...,k_m$, where m=<n
  * Outputs:
      * List, a list (Macaulay2Doc), a list of element consisting
        of a regularity index and partial degree of homogeneity

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

 Given a system of polynomials $f_0,...,f_n$ of degree $d_0,...,d_n$ that are
contained in a complete intersection $g_1,...,g_m$ of degree $k_1,...,k_m$,
this function returns the regularity index used to form the matrix associated
to the residual resultant over a complete intersection and then all the partial
degrees of this resultant with respect to the coefficients of $f_0,f_1,..,f_n$.
+-----------------------------------------------------------------------------+
|i1 : R=ZZ[d_0..d_3,k_1,k_2]                                                  |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : L=ciResDeg({d_0,d_1,d_2,d_3},{k_1,k_2})                                 |
|                                                                             |
|                                                                         2   |
|o2 = {d  + d  + d  + d  - 3k  - 3, {d d d  - d k k  - d k k  - d k k  + k k  |
|       0    1    2    3     2        1 2 3    1 1 2    2 1 2    3 1 2    1 2 |
|     ------------------------------------------------------------------------|
|          2                                       2        2                 |
|     + k k , d d d  - d k k  - d k k  - d k k  + k k  + k k , d d d  - d k k |
|        1 2   0 2 3    0 1 2    2 1 2    3 1 2    1 2    1 2   0 1 3    0 1 2|
|     ------------------------------------------------------------------------|
|                          2        2                                         |
|     - d k k  - d k k  + k k  + k k , d d d  - d k k  - d k k  - d k k  +    |
|        1 1 2    3 1 2    1 2    1 2   0 1 2    0 1 2    1 1 2    2 1 2      |
|     ------------------------------------------------------------------------|
|      2        2                                                             |
|     k k  + k k }}                                                           |
|      1 2    1 2                                                             |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * eliminationMatrix -- returns a matrix that
    represents the image of the map
  * ciResDegGH -- compute a regularity index used for the
    residual resultant over a complete intersection

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

The object ciResDeg, is a function closure (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1488:0.

ciResDegGH -- compute a regularity index used for the residual resultant over a complete intersection
*****************************************************************************************************

  * Usage:
        ciResDegGH(r, m, v)
  * Inputs:
      * v, a list (Macaulay2Doc), list 'var' of variables with
        respect to which the polynomials are homogeneous and from which one
        wants to remove these variables
      * r, a matrix (Macaulay2Doc), a single row matrix
        describing the base locus
      * m, a matrix (Macaulay2Doc), a matrix corresponding to the
        decomposition of a polynomial system over the base locus
  * Outputs:
      * an integer (Macaulay2Doc), a regularity index to form the
        residual resultant-

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

 This function is similar to the first element in the list returned by the
function ciResDeg, but with arguments that are identical to the
ones used with the function eliminationMatrix, using
the Strategy CM2Residual.
+-----------------------------------------------------------------------------+
|i1 : R=QQ[a_0,a_1,a_2,a_3,a_4,b_0,b_1,b_2,b_3,b_4,c_0,c_1,c_2,c_3,c_4,x,y,z] |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : G=matrix{{z,x^2+y^2}}                                                   |
|                                                                             |
|o2 = | z x2+y2 |                                                             |
|                                                                             |
|             1      2                                                        |
|o2 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i3 : H=matrix{{a_0*z+a_1*x+a_2*y,b_0*z+b_1*x+b_2*y,c_0*z+c_1*x+c_2*y},{a_3,b_|
|                                                                             |
|o3 = | a_1x+a_2y+a_0z b_1x+b_2y+b_0z c_1x+c_2y+c_0z |                        |
|     | a_3            b_3            c_3            |                        |
|                                                                             |
|             2      3                                                        |
|o3 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|3,c_3}}                                                                      |
+-----------------------------------------------------------------------------+
|i4 : ciResDegGH({x,y,z},G,H)                                                 |
|                                                                             |
|o4 = 2                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * eliminationMatrix -- returns a matrix that
    represents the image of the map
  * ciResDeg -- compute a regularity index and partial degrees
    of the residual resultant over a complete intersection

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

The object ciResDegGH, is a function closure (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1515:0.

ciResidual -- Strategy for eliminationMatrix.
*********************************************

  * Usage:
        eliminationMatrix(..., Strategy => ciResidual)
  * Consequences:
      * This function basically computes the matrix of the first application in
        the resolution of (I:J) given in the article of Bruns, Kustin and
        Miller: 'The resolution of the generic residual intersection of a
        complete intersection', Journal of Algebra 128.

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

The first argument is a list of homogeneous polynomials $J=(g_1,..,g_m)$
forming a complete intersection with respect to the variables 'varList'. Given
a system of homogeneous  $I=(f_1,..,f_n)$, such that I is included in J and
(I:J) is a residual intersection, one wants to compute a sort of resultant of
(I:J). The second argument is the matrix M such that I=J.M. The output is a
generically (with respect to the other variables than 'varList') surjective
matrix such that the determinant of a maximal minor is a multiple of the
resultant of I on the closure of the complementary of V(J) in V(I). Such a
minor can be obtain withmaxMinor,

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

The object ciResidual, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1587:0.

CM2Residual -- Strategy for eliminationMatrix.
**********************************************

  * Usage:
        eliminationMatrix(..., Strategy => CM2Residual)
  * Consequences:
      * Suppose given a homogeneous ideal locally complete intersection
        Cohen-Macaulay of codimension 2,
      * $J=(g_1,..,g_n)$
      * , such that
      * $I=(f_1,..,f_m)$
      *  is included in J and (I:J) is a residual intersection. Let H be the
        matrix that I=J.H. Let R be the matrix of the first syzygies of J. This
        function computes an elimination matrix corresponding to the residual
        resultant over V(I) over V(J).

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

The object CM2Residual, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1598:0.

degHomPolMap -- return the base of monomials in a subset of variables, and the matrix of coefficients of a morphism of free modules f:R(d1)+...+R(dn)->R_d with respect to these variables
******************************************************************************************************************************************************************************************

  * Usage:
        coefAndMonomials = degHomPolMap(r, l, v, d)
  * Inputs:
      * r, a matrix (Macaulay2Doc), single row matrix with
        polynomials $f_1,...,f_n$
      * l, a list (Macaulay2Doc), list {d1,...,dn} of degrees
        corresponding to the degrees of $f_1,...,f_n$
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R with respect to which the polynomials fi's are
        homogeneous of degree 'di' (to take into account for elimination)
      * d, an integer (Macaulay2Doc), the degree in 'var' of the
        homogeneous strand of the map f (i.e.: R_d)
  * Outputs:
      * List, a list (Macaulay2Doc), a list {monomials,
        coefficients} of the coefficients and monomials of the morphism f

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

Let R be a polynomial ring in two groups of variables $R=S[X_1,...,X_r]$ and
$S=k[a_1,...,a_s]$. Here, $X_1,...,X_r$ are called v and  $a_1,...,a_s$ are
called 'coefficients'. Let m be a line matrix $f_1,...,f_n$, where fi is an
element of R which is homogeneous as a polynomial in the variables 'var', of
degree $di$ for all i in 'var'. The matrix 'm' defines a graded map of
R-modules (of degree 0 in 'var') from $R(-d_1)+...+R(-d_n)$ to R. In
particular, looking on each strand d, we have a map of free S-modules of finite
rank $f_d: R_{d-d_1}+...+R_{d-d_n} -> R_d$ where $R_d$ is the homogeneous part
of degree d in 'var' of R.

This function returns a sequence with two elements: first the list of monomials
of degree d in 'var'; Second, the matrix f_d with entries in S in the base of
monomials.

For computing the base of monomials, it needs as a second argument the list
$d_1,...,d_n$  of the degrees of the fi's in v. There is an auxiliary function
computing this automatically from the list of elements fi's and the list of
variables v called l.
+--------------------------------------+
|i1 : R=QQ[a,b,c,x,y]                  |
|                                      |
|o1 = R                                |
|                                      |
|o1 : PolynomialRing                   |
+--------------------------------------+
|i2 : f1 = a*x^2+b*x*y+c*y^2           |
|                                      |
|        2              2              |
|o2 = a*x  + b*x*y + c*y               |
|                                      |
|o2 : R                                |
+--------------------------------------+
|i3 : f2 = 2*a*x+b*y                   |
|                                      |
|o3 = 2a*x + b*y                       |
|                                      |
|o3 : R                                |
+--------------------------------------+
|i4 : M = matrix{{f1,f2}}              |
|                                      |
|o4 = | ax2+bxy+cy2 2ax+by |           |
|                                      |
|             1      2                 |
|o4 : Matrix R  <-- R                  |
+--------------------------------------+
|i5 : l = {x,y}                        |
|                                      |
|o5 = {x, y}                           |
|                                      |
|o5 : List                             |
+--------------------------------------+
|i6 : dHPM = degHomPolMap (M,l,2)      |
|                                      |
|o6 = (| x2 xy y2 |, {2} | a 2a 0  |)  |
|                    {2} | b b  2a |   |
|                    {2} | c 0  b  |   |
|                                      |
|o6 : Sequence                         |
+--------------------------------------+
|i7 : dHPM = degHomPolMap (M,{2,1},l,2)|
|                                      |
|o7 = (| x2 xy y2 |, {2} | a 2a 0  |)  |
|                    {2} | b b  2a |   |
|                    {2} | c 0  b  |   |
|                                      |
|o7 : Sequence                         |
+--------------------------------------+
+-----------------------------------------+
|i8 : R=QQ[a,b,c,d,e,f,g,h,i,x,y,z]       |
|                                         |
|o8 = R                                   |
|                                         |
|o8 : PolynomialRing                      |
+-----------------------------------------+
|i9 : f1 = a*x+b*y+c*z                    |
|                                         |
|o9 = a*x + b*y + c*z                     |
|                                         |
|o9 : R                                   |
+-----------------------------------------+
|i10 : f2 = d*x+e*y+f*z                   |
|                                         |
|o10 = d*x + e*y + f*z                    |
|                                         |
|o10 : R                                  |
+-----------------------------------------+
|i11 : f3 = g*x+h*y+i*z                   |
|                                         |
|o11 = g*x + h*y + i*z                    |
|                                         |
|o11 : R                                  |
+-----------------------------------------+
|i12 : M = matrix{{f1,f2,f3}}             |
|                                         |
|o12 = | ax+by+cz dx+ey+fz gx+hy+iz |     |
|                                         |
|              1      3                   |
|o12 : Matrix R  <-- R                    |
+-----------------------------------------+
|i13 : l = {x,y,z}                        |
|                                         |
|o13 = {x, y, z}                          |
|                                         |
|o13 : List                               |
+-----------------------------------------+
|i14 : dHPM = degHomPolMap (M,l,1)        |
|                                         |
|o14 = (| x y z |, {1} | a d g |)         |
|                  {1} | b e h |          |
|                  {1} | c f i |          |
|                                         |
|o14 : Sequence                           |
+-----------------------------------------+
|i15 : dHPM = degHomPolMap (M,{1,1,1},l,1)|
|                                         |
|o15 = (| x y z |, {1} | a d g |)         |
|                  {1} | b e h |          |
|                  {1} | c f i |          |
|                                         |
|o15 : Sequence                           |
+-----------------------------------------+

See also
========

  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.
  * coefficients (Macaulay2Doc) -- get the monomials and
    coefficients of a polynomial or matrix

Ways to use degHomPolMap:
=========================

  * "degHomPolMap(Matrix,List,List,ZZ)"
  * "degHomPolMap(Matrix,List,ZZ)"

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

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

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

The source of this document is in EliminationMatrices.m2:888:0.

detComplex -- This function calculates the determinant of a graded Complex with respect to a subset of the variables of the polynomial ring in a fixed degree.
**************************************************************************************************************************************************************

  * Usage:
        deteriminantComplex = detComplex(d,v,C)
  * Inputs:
      * c, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * Strategy, =>
        ..., default value null, choose between Exact and Numeric algorithms
  * Outputs:
      * aPolynomialList, a list (Macaulay2Doc), an element in
        frac(R) that is the alternate product of the elements in the list
        'listDetComplex'

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

This function calculates the determinant of a graded Complex with respect to a
subset of the variables of the polynomial ring in a fixed degree. It
corresponds to the alternate product of the elements in the list
listDetComplex,

The input Complex needs to be an exact complex of free modules over a
polynomial ring. The polynomial ring must contain the list v as variables.

It is recommended not to defines rings as R=QQ[x,y][a,b,c] when the variables
to eliminate are '{x,y}'. In this case, see flattenRing (Macaulay2Doc),
for passing from $R=QQ[x,y][a,b,c]$ to
QQ[x,y,a,b,c].
+--------------------------------------------+
|i1 : R=QQ[a,b,c,x,y]                        |
|                                            |
|o1 = R                                      |
|                                            |
|o1 : PolynomialRing                         |
+--------------------------------------------+
|i2 : f1 = a*x^2+b*x*y+c*y^2                 |
|                                            |
|        2              2                    |
|o2 = a*x  + b*x*y + c*y                     |
|                                            |
|o2 : R                                      |
+--------------------------------------------+
|i3 : f2 = 2*a*x+b*y                         |
|                                            |
|o3 = 2a*x + b*y                             |
|                                            |
|o3 : R                                      |
+--------------------------------------------+
|i4 : M = matrix{{f1,f2}}                    |
|                                            |
|o4 = | ax2+bxy+cy2 2ax+by |                 |
|                                            |
|             1      2                       |
|o4 : Matrix R  <-- R                        |
+--------------------------------------------+
|i5 : l = {x,y}                              |
|                                            |
|o5 = {x, y}                                 |
|                                            |
|o5 : List                                   |
+--------------------------------------------+
|i6 : dHPM = detComplex (2,l,koszulComplex M)|
|                                            |
|          2     2                           |
|o6 = - a*b  + 4a c                          |
|                                            |
|o6 : frac R                                 |
+--------------------------------------------+
|i7 : dHPM = detComplex (3,l,koszulComplex M)|
|                                            |
|          2     2                           |
|o7 = - a*b  + 4a c                          |
|                                            |
|o7 : frac R                                 |
+--------------------------------------------+
+------------------------------------------------------------------+
|i8 : R=QQ[a,b,c,d,e,f,g,h,i,x,y,z]                                |
|                                                                  |
|o8 = R                                                            |
|                                                                  |
|o8 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i9 : f1 = a*x+b*y+c*z                                             |
|                                                                  |
|o9 = a*x + b*y + c*z                                              |
|                                                                  |
|o9 : R                                                            |
+------------------------------------------------------------------+
|i10 : f2 = d*x+e*y+f*z                                            |
|                                                                  |
|o10 = d*x + e*y + f*z                                             |
|                                                                  |
|o10 : R                                                           |
+------------------------------------------------------------------+
|i11 : f3 = g*x+h*y+i*z                                            |
|                                                                  |
|o11 = g*x + h*y + i*z                                             |
|                                                                  |
|o11 : R                                                           |
+------------------------------------------------------------------+
|i12 : M = matrix{{f1,f2,f3}}                                      |
|                                                                  |
|o12 = | ax+by+cz dx+ey+fz gx+hy+iz |                              |
|                                                                  |
|              1      3                                            |
|o12 : Matrix R  <-- R                                             |
+------------------------------------------------------------------+
|i13 : l = {x,y,z}                                                 |
|                                                                  |
|o13 = {x, y, z}                                                   |
|                                                                  |
|o13 : List                                                        |
+------------------------------------------------------------------+
|i14 : dHPM = detComplex (1,l,koszulComplex M)                     |
|                                                                  |
|o14 = - c*e*g + b*f*g + c*d*h - a*f*h - b*d*i + a*e*i             |
|                                                                  |
|o14 : frac R                                                      |
+------------------------------------------------------------------+
|i15 : dHPM = detComplex (2,l,koszulComplex M)                     |
|                                                                  |
|o15 = - c*e*g + b*f*g + c*d*h - a*f*h - b*d*i + a*e*i             |
|                                                                  |
|o15 : frac R                                                      |
+------------------------------------------------------------------+
|i16 : dHPM = detComplex (1,l,koszulComplex M, Strategy => Exact)  |
|                                                                  |
|o16 = - c*e*g + b*f*g + c*d*h - a*f*h - b*d*i + a*e*i             |
|                                                                  |
|o16 : frac R                                                      |
+------------------------------------------------------------------+
|i17 : dHPM = detComplex (1,l,koszulComplex M, Strategy => Numeric)|
|                                                                  |
|o17 = - c*e*g + b*f*g + c*d*h - a*f*h - b*d*i + a*e*i             |
|                                                                  |
|o17 : frac R                                                      |
+------------------------------------------------------------------+

See also
========

  * degHomPolMap -- return the base of monomials in a
    subset of variables, and the matrix of coefficients of a morphism of free
    modules f:R(d1)+...+R(dn)->R_d with respect to these variables
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.

Ways to use detComplex:
=======================

  * "detComplex(ZZ,List,Complex)"

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

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

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

The source of this document is in EliminationMatrices.m2:1062:0.

detComplex(...,Strategy=>...) -- choose between Exact and Numeric algorithms
****************************************************************************

  * Usage:
        detComplex(d,v,C, Strategy => s)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
      * s, a symbol (Macaulay2Doc), either Exact or Numeric
  * Consequences:
      * If s is Exact, then therank (Macaulay2Doc),
        algorithms is used computing minors; if s is Numeric,
        then numerical rank computation is used, this is, all coefficients are
        evaluated in the ground field before computing ranks.

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

See Exact,is the default Strategy.

See also
========

  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * detComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "eliminationMatrix(...,Strategy=>...)" -- see eliminationMatrix,
    -- returns a matrix that represents the image of the map
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * epicResolutionMap(...,Strategy=>...) (missing documentation)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * listDetComplex(...,Strategy=>...)
    -- choose between
    Exact and Numeric algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * maxCol(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * maxMinor(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * minorsComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * pruneComplex(...,Strategy=>...) (Complexes)
    -- Whether to
    use the methods in the package or C++ algorithms in the engine
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * "freeResolution(...,Strategy=>...)" -- see Strategies for free resolutions (Complexes),
    -- overview of the
    different algorithms for computing free resolutions
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: detComplex, -- This function calculates the
    determinant of a graded Complex with respect to a subset of the variables
    of the polynomial ring in a fixed degree.
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1085:0.

determinantal -- Strategy for eliminationMatrix.
************************************************

  * Usage:
        eliminationMatrix(..., Strategy => determinantal)
  * Consequences:
      * Compute the determinantal resultant of an (n,m)-matrix (n<m) of
        homogeneous polynomials over the projective space of dimension m-n,
        i.e. a condition on the parameters of these polynomials to have
        rank(M)<n.

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

The object determinantal, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1574:0.

detResDeg -- compute a regularity index and partial degrees of the determinantal resultant
******************************************************************************************

  * Usage:
        detResDeg(n, c, r, R)
  * Inputs:
      * n, an integer (Macaulay2Doc),  corresponding to the drop of
        rank used to form the determinantal resultant
      * c, a list (Macaulay2Doc), a list of degrees indexing the
        columns of a polynomial matrix
      * r, a list (Macaulay2Doc), a list of degrees indexing the
        rows of the same polynomial
      * R, a ring (Macaulay2Doc),  an ambient ring where the
        computations take place
  * Outputs:
      * a list (Macaulay2Doc), a list of element consisting of a
        regularity index and partial degree of homogeneity of the
        determinantal resultant

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

 Compute the regularity index and the multi-degree of the determinantal
resultant associated to the matrix M
+-----------------------------------------------------------------------------+
|i1 : R = ZZ[d1,d2,d3,k1,k2]                                                  |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : detResDeg(1,{d1,d2,d3},{k1,k2},R)                                       |
|                                                                             |
|o2 = {d1 + d2 + d3 - k1 - 2k2 - 1, {d2 + d3 - k1 - k2, d1 + d3 - k1 - k2, d1 |
|     ------------------------------------------------------------------------|
|     + d2 - k1 - k2}}                                                        |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * macaulayFormula -- returns two matrices such that
    the ratio of their determinants is the Macaulay resultant
  * eliminationMatrix -- returns a matrix that
    represents the image of the map
  * ciResDeg -- compute a regularity index and partial degrees
    of the residual resultant over a complete intersection
  * bezoutianMatrix -- returns a matrix associated to
    generalized resultants

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

The object detResDeg, is a function closure (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1461:0.

eliminationMatrix -- returns a matrix that represents the image of the map
**************************************************************************

  * Usage:
        eliminationMatrix(..., Strategy => s)
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value null

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

If the strategy 's' is 'Sylvester':

Refer to sylvesterMatrix (Elimination),

If the strategy 's' is 'Macaulay':

Let $f_1,..,f_n$ be a polynomials two groups of variables $X_1,...,X_n$ and
$a_1,...,a_s$ and such that $f_1,...,f_n$ are homogeneous polynomials with
respect to the variables $X_1,...,X_n$. This function returns a matrix which is
generically (in terms of the parameters $a_1,...,a_s$) surjective such that the
gcd of its maximal minors is the Macaulay resultant of $f_1,...,f_n$.
+-------------------------------------------------------+
|i1 : R=QQ[a_0..a_8,x,y,z]                              |
|                                                       |
|o1 = R                                                 |
|                                                       |
|o1 : PolynomialRing                                    |
+-------------------------------------------------------+
|i2 : f1 = a_0*x+a_1*y+a_2*z                            |
|                                                       |
|o2 = a x + a y + a z                                   |
|      0     1     2                                    |
|                                                       |
|o2 : R                                                 |
+-------------------------------------------------------+
|i3 : f2 = a_3*x+a_4*y+a_5*z                            |
|                                                       |
|o3 = a x + a y + a z                                   |
|      3     4     5                                    |
|                                                       |
|o3 : R                                                 |
+-------------------------------------------------------+
|i4 : f3 = a_6*x+a_7*y+a_8*z                            |
|                                                       |
|o4 = a x + a y + a z                                   |
|      6     7     8                                    |
|                                                       |
|o4 : R                                                 |
+-------------------------------------------------------+
|i5 : M = matrix{{f1,f2,f3}}                            |
|                                                       |
|o5 = | a_0x+a_1y+a_2z a_3x+a_4y+a_5z a_6x+a_7y+a_8z |  |
|                                                       |
|             1      3                                  |
|o5 : Matrix R  <-- R                                   |
+-------------------------------------------------------+
|i6 : l = {x,y,z}                                       |
|                                                       |
|o6 = {x, y, z}                                         |
|                                                       |
|o6 : List                                              |
+-------------------------------------------------------+
|i7 : MR = eliminationMatrix (l,M, Strategy => Macaulay)|
|                                                       |
|o7 = {1} | a_0 a_3 a_6 |                               |
|     {1} | a_1 a_4 a_7 |                               |
|     {1} | a_2 a_5 a_8 |                               |
|                                                       |
|             3      3                                  |
|o7 : Matrix R  <-- R                                   |
+-------------------------------------------------------+

If the strategy 's' is 'determinantal':

 Compute the determinantal resultant of an (n,m)-matrix (n<m) of homogeneous
polynomials over the projective space of dimension (m-r)(n-r), i.e. a condition
on the parameters of these polynomials to have rank(M)<r+1.
+-----------------------------------------------------------------------------+
|i8 : R=QQ[a_0..a_5,b_0..b_5,x,y]                                             |
|                                                                             |
|o8 = R                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : M:=matrix{{a_0*x+a_1*y,a_2*x+a_3*y,a_4*x+a_5*y},{b_0*x+b_1*y,b_2*x+b_3*y|
|                                                                             |
|o9 = | a_0x+a_1y a_2x+a_3y a_4x+a_5y |                                       |
|     | b_0x+b_1y b_2x+b_3y b_4x+b_5y |                                       |
|                                                                             |
|             2      3                                                        |
|o9 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|,b_4*x+b_5*y}}                                                               |
+-----------------------------------------------------------------------------+
|i10 : eliminationMatrix(1,{x,y},M, Strategy => determinantal)                |
|                                                                             |
|o10 = {2} | -a_2b_0+a_0b_2               -a_4b_0+a_0b_4                      |
|      {2} | -a_3b_0-a_2b_1+a_1b_2+a_0b_3 -a_5b_0-a_4b_1+a_1b_4+a_0b_5        |
|      {2} | -a_3b_1+a_1b_3               -a_5b_1+a_1b_5                      |
|      -----------------------------------------------------------------------|
|      -a_4b_2+a_2b_4               |                                         |
|      -a_5b_2-a_4b_3+a_3b_4+a_2b_5 |                                         |
|      -a_5b_3+a_3b_5               |                                         |
|                                                                             |
|              3      3                                                       |
|o10 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+

If the strategy 's' is 'CM2Residual':

 Suppose given a homogeneous ideal locally complete intersection Cohen-Macaulay
of codimension 2,$J=(g_1,..,g_n)$, such that $I=(f1,..,fm)$ is included in J
and (I:J) is a residual intersection. Let H be the matrix that I=J.H. Let R be
the matrix of the first syzygies of J. This function computes an elimination
matrix corresponding to the residual resultant over V(I) over V(J).
+-----------------------------------------------------------------------------+
|i11 : R = QQ[X,Y,Z,x,y,z]                                                    |
|                                                                             |
|o11 = R                                                                      |
|                                                                             |
|o11 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i12 : F = matrix{{x*y^2,y^3,x*z^2,y^3+z^3}}                                  |
|                                                                             |
|o12 = | xy2 y3 xz2 y3+z3 |                                                   |
|                                                                             |
|              1      4                                                       |
|o12 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i13 : G = matrix{{y^2,z^2}}                                                  |
|                                                                             |
|o13 = | y2 z2 |                                                              |
|                                                                             |
|              1      2                                                       |
|o13 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i14 : M = matrix{{1,0,0},{0,1,0},{0,0,1},{-X,-Y,-Z}}                         |
|                                                                             |
|o14 = | 1  0  0  |                                                           |
|      | 0  1  0  |                                                           |
|      | 0  0  1  |                                                           |
|      | -X -Y -Z |                                                           |
|                                                                             |
|              4      3                                                       |
|o14 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i15 : H = (F//G)*M                                                           |
|                                                                             |
|o15 = {2} | -Xy+x -Yy+y -Zy   |                                              |
|      {2} | -Xz   -Yz   -Zz+x |                                              |
|                                                                             |
|              2      3                                                       |
|o15 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i16 : l = {x,y,z}                                                            |
|                                                                             |
|o16 = {x, y, z}                                                              |
|                                                                             |
|o16 : List                                                                   |
+-----------------------------------------------------------------------------+
|i17 : L=eliminationMatrix (l,G,H, Strategy => CM2Residual)                   |
|                                                                             |
|o17 = {3} | 0  0   0  0  0  0  1  0  0  0    0    0    |                     |
|      {3} | 0  0   0  0  0  0  -X 1  0  -Y+1 0    0    |                     |
|      {3} | 0  0   -Y 0  0  0  -Z 0  1  0    0    0    |                     |
|      {3} | -1 0   0  0  0  0  0  -X 0  0    -Y+1 0    |                     |
|      {3} | 0  0   X  -Y 0  0  0  -Z -X -Z   0    -Y+1 |                     |
|      {3} | 0  0   0  0  -Y -1 0  0  -Z 0    0    0    |                     |
|      {3} | X  Y-1 0  0  0  Z  0  0  0  0    0    0    |                     |
|      {3} | 0  0   0  X  0  0  0  0  0  0    -Z   0    |                     |
|      {3} | 0  0   0  0  X  0  0  0  0  0    0    -Z   |                     |
|      {3} | X  Y   0  0  0  Z  0  0  0  0    0    0    |                     |
|                                                                             |
|              10      12                                                     |
|o17 : Matrix R   <-- R                                                       |
+-----------------------------------------------------------------------------+
|i18 : maxCol L                                                               |
|                                                                             |
|o18 = {{3} | 0  0   0  0  0  0  1  0  0  0    |, {0, 1, 2, 3, 4, 5, 6, 7, 8, |
|       {3} | 0  0   0  0  0  0  -X 1  0  -Y+1 |                              |
|       {3} | 0  0   -Y 0  0  0  -Z 0  1  0    |                              |
|       {3} | -1 0   0  0  0  0  0  -X 0  0    |                              |
|       {3} | 0  0   X  -Y 0  0  0  -Z -X -Z   |                              |
|       {3} | 0  0   0  0  -Y -1 0  0  -Z 0    |                              |
|       {3} | X  Y-1 0  0  0  Z  0  0  0  0    |                              |
|       {3} | 0  0   0  X  0  0  0  0  0  0    |                              |
|       {3} | 0  0   0  0  X  0  0  0  0  0    |                              |
|       {3} | X  Y   0  0  0  Z  0  0  0  0    |                              |
|      -----------------------------------------------------------------------|
|      9}}                                                                    |
|                                                                             |
|o18 : List                                                                   |
+-----------------------------------------------------------------------------+

If the strategy 's' is 'ciResidual':

This function basically computes the matrix of the first application in the
resolution of (I:J) given in the article of Bruns, Kustin and Miller: 'The
resolution of the generic residual intersection of a complete intersection',
Journal of Algebra 128.

The first argument is a list of homogeneous polynomials $J=(g_1,..,g_m)$
forming a complete intersection with respect to the variables 'varList'. Given
a system of homogeneous $I=(f_1,..,f_n)$ such that I is included in J and (I:J)
is a residual intersection, one wants to compute a sort of resultant of (I:J).
The second argument is the matrix M such that I=J.M. The output is a
generically (with respect to the other variables than 'varList') surjective
matrix such that the determinant of a maximal minor is a multiple of the
resultant of I on the closure of the complementary of V(J) in V(I). Such a
minor can be obtain with maxMinor.
+-----------------------------------------------------------------------------+
|i19 : R=QQ[a_0,a_1,a_2,a_3,a_4,b_0,b_1,b_2,b_3,b_4,c_0,c_1,c_2,c_3,c_4,x,y,z]|
|                                                                             |
|o19 = R                                                                      |
|                                                                             |
|o19 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i20 : G=matrix{{z,x^2+y^2}}                                                  |
|                                                                             |
|o20 = | z x2+y2 |                                                            |
|                                                                             |
|              1      2                                                       |
|o20 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i21 : H=matrix{{a_0*z+a_1*x+a_2*y,b_0*z+b_1*x+b_2*y,c_0*z+c_1*x+c_2*y},{a_3,b|
|                                                                             |
|o21 = | a_1x+a_2y+a_0z b_1x+b_2y+b_0z c_1x+c_2y+c_0z |                       |
|      | a_3            b_3            c_3            |                       |
|                                                                             |
|              2      3                                                       |
|o21 : Matrix R  <-- R                                                        |
|-----------------------------------------------------------------------------|
|_3,c_3}}                                                                     |
+-----------------------------------------------------------------------------+
|i22 : L=eliminationMatrix ({x,y,z},G,H, Strategy => ciResidual)              |
|                                                                             |
|o22 = {2} | a_3 b_3 c_3 -a_3b_1+a_1b_3 0              0                      |
|      {2} | 0   0   0   -a_3b_2+a_2b_3 -a_3b_1+a_1b_3 0                      |
|      {2} | a_1 b_1 c_1 -a_3b_0+a_0b_3 0              -a_3b_1+a_1b_3         |
|      {2} | a_3 b_3 c_3 0              -a_3b_2+a_2b_3 0                      |
|      {2} | a_2 b_2 c_2 0              -a_3b_0+a_0b_3 -a_3b_2+a_2b_3         |
|      {2} | a_0 b_0 c_0 0              0              -a_3b_0+a_0b_3         |
|      -----------------------------------------------------------------------|
|      -a_3c_1+a_1c_3 0              0              -b_3c_1+b_1c_3            |
|      -a_3c_2+a_2c_3 -a_3c_1+a_1c_3 0              -b_3c_2+b_2c_3            |
|      -a_3c_0+a_0c_3 0              -a_3c_1+a_1c_3 -b_3c_0+b_0c_3            |
|      0              -a_3c_2+a_2c_3 0              0                         |
|      0              -a_3c_0+a_0c_3 -a_3c_2+a_2c_3 0                         |
|      0              0              -a_3c_0+a_0c_3 0                         |
|      -----------------------------------------------------------------------|
|      0              0              |                                        |
|      -b_3c_1+b_1c_3 0              |                                        |
|      0              -b_3c_1+b_1c_3 |                                        |
|      -b_3c_2+b_2c_3 0              |                                        |
|      -b_3c_0+b_0c_3 -b_3c_2+b_2c_3 |                                        |
|      0              -b_3c_0+b_0c_3 |                                        |
|                                                                             |
|              6      12                                                      |
|o22 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+

If the strategy is 'byResolution':

This function computes the matrix of the first application in the resolution of
(I:J) given by freeResolution (Complexes),in degree
regularity (Macaulay2Doc),
+-----------------------------------------------------------------------------+
|i23 : R=QQ[a_0,a_1,a_2,a_3,a_4,b_0,b_1,b_2,b_3,b_4,c_0,c_1,c_2,c_3,c_4,x,y,z]|
|                                                                             |
|o23 = R                                                                      |
|                                                                             |
|o23 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i24 : G=matrix{{z,x^2+y^2}}                                                  |
|                                                                             |
|o24 = | z x2+y2 |                                                            |
|                                                                             |
|              1      2                                                       |
|o24 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i25 : H=matrix{{a_0*z+a_1*x+a_2*y,b_0*z+b_1*x+b_2*y,c_0*z+c_1*x+c_2*y},{a_3,b|
|                                                                             |
|o25 = | a_1x+a_2y+a_0z b_1x+b_2y+b_0z c_1x+c_2y+c_0z |                       |
|      | a_3            b_3            c_3            |                       |
|                                                                             |
|              2      3                                                       |
|o25 : Matrix R  <-- R                                                        |
|-----------------------------------------------------------------------------|
|_3,c_3}}                                                                     |
+-----------------------------------------------------------------------------+
|i26 : L=eliminationMatrix ({x,y,z},G,H, Strategy => byResolution)            |
|                                                                             |
|o26 = {2} | a_3b_1-a_1b_3 0             0             a_3c_1-a_1c_3          |
|      {2} | a_3b_2-a_2b_3 a_3b_1-a_1b_3 0             a_3c_2-a_2c_3          |
|      {2} | a_3b_0-a_0b_3 0             a_3b_1-a_1b_3 a_3c_0-a_0c_3          |
|      {2} | 0             a_3b_2-a_2b_3 0             0                      |
|      {2} | 0             a_3b_0-a_0b_3 a_3b_2-a_2b_3 0                      |
|      {2} | 0             0             a_3b_0-a_0b_3 0                      |
|      -----------------------------------------------------------------------|
|      0             0             b_3c_1-b_1c_3 0             0              |
|      a_3c_1-a_1c_3 0             b_3c_2-b_2c_3 b_3c_1-b_1c_3 0              |
|      0             a_3c_1-a_1c_3 b_3c_0-b_0c_3 0             b_3c_1-b_1c_3  |
|      a_3c_2-a_2c_3 0             0             b_3c_2-b_2c_3 0              |
|      a_3c_0-a_0c_3 a_3c_2-a_2c_3 0             b_3c_0-b_0c_3 b_3c_2-b_2c_3  |
|      0             a_3c_0-a_0c_3 0             0             b_3c_0-b_0c_3  |
|      -----------------------------------------------------------------------|
|      a_3 b_3 c_3 |                                                          |
|      0   0   0   |                                                          |
|      a_1 b_1 c_1 |                                                          |
|      a_3 b_3 c_3 |                                                          |
|      a_2 b_2 c_2 |                                                          |
|      a_0 b_0 c_0 |                                                          |
|                                                                             |
|              6      12                                                      |
|o26 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * macaulayFormula -- returns two matrices such that
    the ratio of their determinants is the Macaulay resultant
  * bezoutianMatrix -- returns a matrix associated to
    generalized resultants

Ways to use eliminationMatrix:
==============================

  * eliminationMatrix(List,Matrix),
    -- returns a matrix associated to the Macaulay resultant
  * eliminationMatrix(List,Matrix,Matrix)
    -- returns a matrix
    corresponding to a residual resultant
  * eliminationMatrix(ZZ,List,Matrix)
    -- returns a matrix
    corresponding to the determinantal resultant, in particular the Macaulay
    resultant

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

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

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

The source of this document is in EliminationMatrices.m2:1431:0.

eliminationMatrix(List,Matrix) -- returns a matrix associated to the Macaulay resultant
***************************************************************************************

  * Function: eliminationMatrix,
  * Usage:
        eliminationMatrix(v,m)
  * Inputs:
      * v, a list (Macaulay2Doc),  a list of n variables such that
        the polynomials $f_1,...,f_n$ are homogeneous with respect to these
        variables
      * m, a matrix (Macaulay2Doc),  a single row matrix with
        polynomials $f_1,...,f_n$
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ..., default value null, returns
        a matrix that represents the image of the map
  * Outputs:
      * a matrix (Macaulay2Doc), a generically surjective matrix
        such that the gcd of its maximal minors if the Macaulay resultant of
        f1,...,fn with respect to the variables 'varList'

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

Let $f_1,...,f_n$ be a polynomials two groups of variables $X_1,...,X_n$ and
$a_1,...,a_s$ and such that $f_1,...,f_n$ are homogeneous polynomials with
respect to the variables $X_1,...,X_n$. This function returns a matrix which is
generically (in terms of the parameters $a_1,...,a_s$) surjective such that the
gcd of its maximal minors is the Macaulay resultant of $f_1,...,f_n$
+-----------------------------------+
|i1 : R=QQ[a..i,x,y,z]              |
|                                   |
|o1 = R                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : f1 = a*x+b*y+c*z              |
|                                   |
|o2 = a*x + b*y + c*z               |
|                                   |
|o2 : R                             |
+-----------------------------------+
|i3 : f2 = d*x+e*y+f*z              |
|                                   |
|o3 = d*x + e*y + f*z               |
|                                   |
|o3 : R                             |
+-----------------------------------+
|i4 : f3 = g*x+h*y+i*z              |
|                                   |
|o4 = g*x + h*y + i*z               |
|                                   |
|o4 : R                             |
+-----------------------------------+
|i5 : M = matrix{{f1,f2,f3}}        |
|                                   |
|o5 = | ax+by+cz dx+ey+fz gx+hy+iz ||
|                                   |
|             1      3              |
|o5 : Matrix R  <-- R               |
+-----------------------------------+
|i6 : l = {x,y,z}                   |
|                                   |
|o6 = {x, y, z}                     |
|                                   |
|o6 : List                          |
+-----------------------------------+
|i7 : MR = eliminationMatrix (l,M)  |
|                                   |
|o7 = {1} | a d g |                 |
|     {1} | b e h |                 |
|     {1} | c f i |                 |
|                                   |
|             3      3              |
|o7 : Matrix R  <-- R               |
+-----------------------------------+

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

  * eliminationMatrix(List,Matrix),
    -- returns a matrix associated to the Macaulay resultant
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1261:0.

eliminationMatrix(List,Matrix,Matrix) -- returns a matrix corresponding to a residual resultant
***********************************************************************************************

  * Function: eliminationMatrix,
  * Usage:
        eliminationMatrix(v, r, m)
  * Inputs:
      * v, a list (Macaulay2Doc), list v of variables with respect
        to which the polynomials are homogeneous and from which one wants to
        remove these variables
      * r, a matrix (Macaulay2Doc), a single row matrix
        describing the base locus
      * m, a matrix (Macaulay2Doc), a matrix corresponding to the
        decomposition of a polynomial system over the base locus
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ..., default value null, returns
        a matrix that represents the image of the map
  * Outputs:
      * a matrix (Macaulay2Doc), a matrix corresponding to the
        residual resultant

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

If the strategy is 'CM2Residual':

 Suppose given a homogeneous ideal locally complete intersection Cohen-Macaulay
codimension 2 $J=(g_1,..,g_n)$, such that $I=(f_1,..,f_m)$ is included in J and
(I:J) is a residual intersection. Let H be the matrix that I=J.H. Let R be the
matrix of the first syzygies of J. This function computes an elimination matrix
corresponding to the residual resultant over V(I) over V(J).
+-----------------------------------------------------------------------------+
|i1 : R = QQ[X,Y,Z,x,y,z]                                                     |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : F = matrix{{x*y^2,y^3,x*z^2,y^3+z^3}}                                   |
|                                                                             |
|o2 = | xy2 y3 xz2 y3+z3 |                                                    |
|                                                                             |
|             1      4                                                        |
|o2 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i3 : G = matrix{{y^2,z^2}}                                                   |
|                                                                             |
|o3 = | y2 z2 |                                                               |
|                                                                             |
|             1      2                                                        |
|o3 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i4 : M = matrix{{1,0,0},{0,1,0},{0,0,1},{-X,-Y,-Z}}                          |
|                                                                             |
|o4 = | 1  0  0  |                                                            |
|     | 0  1  0  |                                                            |
|     | 0  0  1  |                                                            |
|     | -X -Y -Z |                                                            |
|                                                                             |
|             4      3                                                        |
|o4 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i5 : H = (F//G)*M                                                            |
|                                                                             |
|o5 = {2} | -Xy+x -Yy+y -Zy   |                                               |
|     {2} | -Xz   -Yz   -Zz+x |                                               |
|                                                                             |
|             2      3                                                        |
|o5 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i6 : l = {x,y,z}                                                             |
|                                                                             |
|o6 = {x, y, z}                                                               |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : L=eliminationMatrix (l,G,H, Strategy => CM2Residual)                    |
|                                                                             |
|o7 = {3} | 0  0   0  0  0  0  1  0  0  0    0    0    |                      |
|     {3} | 0  0   0  0  0  0  -X 1  0  -Y+1 0    0    |                      |
|     {3} | 0  0   -Y 0  0  0  -Z 0  1  0    0    0    |                      |
|     {3} | -1 0   0  0  0  0  0  -X 0  0    -Y+1 0    |                      |
|     {3} | 0  0   X  -Y 0  0  0  -Z -X -Z   0    -Y+1 |                      |
|     {3} | 0  0   0  0  -Y -1 0  0  -Z 0    0    0    |                      |
|     {3} | X  Y-1 0  0  0  Z  0  0  0  0    0    0    |                      |
|     {3} | 0  0   0  X  0  0  0  0  0  0    -Z   0    |                      |
|     {3} | 0  0   0  0  X  0  0  0  0  0    0    -Z   |                      |
|     {3} | X  Y   0  0  0  Z  0  0  0  0    0    0    |                      |
|                                                                             |
|             10      12                                                      |
|o7 : Matrix R   <-- R                                                        |
+-----------------------------------------------------------------------------+
|i8 : maxCol L                                                                |
|                                                                             |
|o8 = {{3} | 0  0   0  0  0  0  1  0  0  0    |, {0, 1, 2, 3, 4, 5, 6, 7, 8,  |
|      {3} | 0  0   0  0  0  0  -X 1  0  -Y+1 |                               |
|      {3} | 0  0   -Y 0  0  0  -Z 0  1  0    |                               |
|      {3} | -1 0   0  0  0  0  0  -X 0  0    |                               |
|      {3} | 0  0   X  -Y 0  0  0  -Z -X -Z   |                               |
|      {3} | 0  0   0  0  -Y -1 0  0  -Z 0    |                               |
|      {3} | X  Y-1 0  0  0  Z  0  0  0  0    |                               |
|      {3} | 0  0   0  X  0  0  0  0  0  0    |                               |
|      {3} | 0  0   0  0  X  0  0  0  0  0    |                               |
|      {3} | X  Y   0  0  0  Z  0  0  0  0    |                               |
|     ------------------------------------------------------------------------|
|     9}}                                                                     |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

If the strategy is 'ciResidual':

This function basically computes the matrix of the first application in the
resolution of (I:J) given in the article of Bruns, Kustin and Miller: 'The
resolution of the generic residual intersection of a complete intersection',
Journal of Algebra 128.

The first argument is a list of homogeneous polynomials $J=(g_1,..,g_n)$forming
a complete intersection with respect to the variables 'varList'. Given a system
of homogeneous $I=(f_1,..,f_m)$, such that I is included in J and (I:J) is a
residual intersection, one wants to compute a sort of resultant of (I:J). The
second argument is the matrix M such that I=J.M. The output is a generically
(with respect to the other variables than v) surjective matrix such that the
determinant of a maximal minor is a multiple of the resultant of I on the
closure of the complementary of V(J) in V(I). Such a minor can be obtain with
maxMinor.
+-----------------------------------------------------------------------------+
|i9 : R=QQ[a_0,a_1,a_2,a_3,a_4,b_0,b_1,b_2,b_3,b_4,c_0,c_1,c_2,c_3,c_4,x,y,z] |
|                                                                             |
|o9 = R                                                                       |
|                                                                             |
|o9 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i10 : G=matrix{{z,x^2+y^2}}                                                  |
|                                                                             |
|o10 = | z x2+y2 |                                                            |
|                                                                             |
|              1      2                                                       |
|o10 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i11 : H=matrix{{a_0*z+a_1*x+a_2*y,b_0*z+b_1*x+b_2*y,c_0*z+c_1*x+c_2*y},{a_3,b|
|                                                                             |
|o11 = | a_1x+a_2y+a_0z b_1x+b_2y+b_0z c_1x+c_2y+c_0z |                       |
|      | a_3            b_3            c_3            |                       |
|                                                                             |
|              2      3                                                       |
|o11 : Matrix R  <-- R                                                        |
|-----------------------------------------------------------------------------|
|_3,c_3}}                                                                     |
+-----------------------------------------------------------------------------+
|i12 : L=eliminationMatrix ({x,y,z},G,H, Strategy => ciResidual)              |
|                                                                             |
|o12 = {2} | a_3 b_3 c_3 -a_3b_1+a_1b_3 0              0                      |
|      {2} | 0   0   0   -a_3b_2+a_2b_3 -a_3b_1+a_1b_3 0                      |
|      {2} | a_1 b_1 c_1 -a_3b_0+a_0b_3 0              -a_3b_1+a_1b_3         |
|      {2} | a_3 b_3 c_3 0              -a_3b_2+a_2b_3 0                      |
|      {2} | a_2 b_2 c_2 0              -a_3b_0+a_0b_3 -a_3b_2+a_2b_3         |
|      {2} | a_0 b_0 c_0 0              0              -a_3b_0+a_0b_3         |
|      -----------------------------------------------------------------------|
|      -a_3c_1+a_1c_3 0              0              -b_3c_1+b_1c_3            |
|      -a_3c_2+a_2c_3 -a_3c_1+a_1c_3 0              -b_3c_2+b_2c_3            |
|      -a_3c_0+a_0c_3 0              -a_3c_1+a_1c_3 -b_3c_0+b_0c_3            |
|      0              -a_3c_2+a_2c_3 0              0                         |
|      0              -a_3c_0+a_0c_3 -a_3c_2+a_2c_3 0                         |
|      0              0              -a_3c_0+a_0c_3 0                         |
|      -----------------------------------------------------------------------|
|      0              0              |                                        |
|      -b_3c_1+b_1c_3 0              |                                        |
|      0              -b_3c_1+b_1c_3 |                                        |
|      -b_3c_2+b_2c_3 0              |                                        |
|      -b_3c_0+b_0c_3 -b_3c_2+b_2c_3 |                                        |
|      0              -b_3c_0+b_0c_3 |                                        |
|                                                                             |
|              6      12                                                      |
|o12 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+

If the strategy is 'byResolution':

This function computes the matrix of the first application in the resolution of
(I:J) given by freeResolution (Complexes),in degree
regularity (Macaulay2Doc),
+-----------------------------------------------------------------------------+
|i13 : R=QQ[a_0,a_1,a_2,a_3,a_4,b_0,b_1,b_2,b_3,b_4,c_0,c_1,c_2,c_3,c_4,x,y,z]|
|                                                                             |
|o13 = R                                                                      |
|                                                                             |
|o13 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i14 : G=matrix{{z,x^2+y^2}}                                                  |
|                                                                             |
|o14 = | z x2+y2 |                                                            |
|                                                                             |
|              1      2                                                       |
|o14 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i15 : H=matrix{{a_0*z+a_1*x+a_2*y,b_0*z+b_1*x+b_2*y,c_0*z+c_1*x+c_2*y},{a_3,b|
|                                                                             |
|o15 = | a_1x+a_2y+a_0z b_1x+b_2y+b_0z c_1x+c_2y+c_0z |                       |
|      | a_3            b_3            c_3            |                       |
|                                                                             |
|              2      3                                                       |
|o15 : Matrix R  <-- R                                                        |
|-----------------------------------------------------------------------------|
|_3,c_3}}                                                                     |
+-----------------------------------------------------------------------------+
|i16 : L=eliminationMatrix ({x,y,z},G,H, Strategy => byResolution)            |
|                                                                             |
|o16 = {2} | a_3b_1-a_1b_3 0             0             a_3c_1-a_1c_3          |
|      {2} | a_3b_2-a_2b_3 a_3b_1-a_1b_3 0             a_3c_2-a_2c_3          |
|      {2} | a_3b_0-a_0b_3 0             a_3b_1-a_1b_3 a_3c_0-a_0c_3          |
|      {2} | 0             a_3b_2-a_2b_3 0             0                      |
|      {2} | 0             a_3b_0-a_0b_3 a_3b_2-a_2b_3 0                      |
|      {2} | 0             0             a_3b_0-a_0b_3 0                      |
|      -----------------------------------------------------------------------|
|      0             0             b_3c_1-b_1c_3 0             0              |
|      a_3c_1-a_1c_3 0             b_3c_2-b_2c_3 b_3c_1-b_1c_3 0              |
|      0             a_3c_1-a_1c_3 b_3c_0-b_0c_3 0             b_3c_1-b_1c_3  |
|      a_3c_2-a_2c_3 0             0             b_3c_2-b_2c_3 0              |
|      a_3c_0-a_0c_3 a_3c_2-a_2c_3 0             b_3c_0-b_0c_3 b_3c_2-b_2c_3  |
|      0             a_3c_0-a_0c_3 0             0             b_3c_0-b_0c_3  |
|      -----------------------------------------------------------------------|
|      a_3 b_3 c_3 |                                                          |
|      0   0   0   |                                                          |
|      a_1 b_1 c_1 |                                                          |
|      a_3 b_3 c_3 |                                                          |
|      a_2 b_2 c_2 |                                                          |
|      a_0 b_0 c_0 |                                                          |
|                                                                             |
|              6      12                                                      |
|o16 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+

See also
========

  * macaulayFormula -- returns two matrices such that
    the ratio of their determinants is the Macaulay resultant
  * bezoutianMatrix -- returns a matrix associated to
    generalized resultants

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

  * eliminationMatrix(List,Matrix,Matrix)
    -- returns a matrix
    corresponding to a residual resultant
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1350:0.

eliminationMatrix(ZZ,List,Matrix) -- returns a matrix corresponding to the determinantal resultant, in particular the Macaulay resultant
****************************************************************************************************************************************

  * Function: eliminationMatrix,
  * Usage:
        eliminationMatrix(r, v, m)
  * Inputs:
      * r, an integer (Macaulay2Doc), corresponding to the regularity
        index used to form the determinantal resultant
      * v, a list (Macaulay2Doc),  a list of homogeneous variables
        that are to be eliminated
      * m, a matrix (Macaulay2Doc), a polynomial matrix
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ..., default value null, returns
        a matrix that represents the image of the map
  * Outputs:
      * M, a matrix (Macaulay2Doc), a matrix corresponding to the
        determinantal resultant

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

 Compute the determinantal resultant of an (n,m)-matrix (n<m) of homogeneous
polynomials over the projective space of dimension (m-r)(n-r), i.e. a condition
on the parameters of these polynomials to have rank(M)<r+1.M
+-----------------------------------------------------------------------------+
|i1 : R=QQ[a_0..a_5,b_0..b_5,x,y]                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M:=matrix{{a_0*x+a_1*y,a_2*x+a_3*y,a_4*x+a_5*y},{b_0*x+b_1*y,b_2*x+b_3*y|
|                                                                             |
|o2 = | a_0x+a_1y a_2x+a_3y a_4x+a_5y |                                       |
|     | b_0x+b_1y b_2x+b_3y b_4x+b_5y |                                       |
|                                                                             |
|             2      3                                                        |
|o2 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|,b_4*x+b_5*y}}                                                               |
+-----------------------------------------------------------------------------+
|i3 : eliminationMatrix(1,{x,y},M, Strategy => determinantal)                 |
|                                                                             |
|o3 = {2} | -a_2b_0+a_0b_2               -a_4b_0+a_0b_4                       |
|     {2} | -a_3b_0-a_2b_1+a_1b_2+a_0b_3 -a_5b_0-a_4b_1+a_1b_4+a_0b_5         |
|     {2} | -a_3b_1+a_1b_3               -a_5b_1+a_1b_5                       |
|     ------------------------------------------------------------------------|
|     -a_4b_2+a_2b_4               |                                          |
|     -a_5b_2-a_4b_3+a_3b_4+a_2b_5 |                                          |
|     -a_5b_3+a_3b_5               |                                          |
|                                                                             |
|             3      3                                                        |
|o3 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * macaulayFormula -- returns two matrices such that
    the ratio of their determinants is the Macaulay resultant
  * bezoutianMatrix -- returns a matrix associated to
    generalized resultants

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

  * eliminationMatrix(ZZ,List,Matrix)
    -- returns a matrix
    corresponding to the determinantal resultant, in particular the Macaulay
    resultant
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1289:0.

Exact -- Strategy for functions that uses rank computation.
***********************************************************

  * Usage:
        Strategy => Exact
  * Consequences:
      * If 'Exact' Strategy is used, then exact rank computation is used. This
        could be notably slower that
      * Numeric -- Strategy for functions that uses rank
        computation.
      *  rank computation when many generic elements are manipulated.

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

The object Exact, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1540:0.

listDetComplex -- This function calculates the list with the determinants of some minors of the maps of a graded Complex with respect to a subset of the variables of the polynomial ring in a fixed degree.
************************************************************************************************************************************************************************************************************

  * Usage:
        listOfTheDetOfTheComplex = listDetComplex(d,v,C)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * Strategy, =>
        ..., default value null, choose between Exact and Numeric algorithms
  * Outputs:
      * a list (Macaulay2Doc), a list with the determinant
        polynomials of the maps computed by 'minorsComplex'

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

This function calculates the list with the determinants of some minors of the
maps of a graded Complex with respect to a subset of the variables of the
polynomial ring in a fixed degree. Precisely, this list corresponds to the list
with the determinant polynomials of the maps computed by minorsComplex.

The input Complex needs to be an exact complex of free modules over a
polynomial ring. The polynomial ring must contain the list v as variables.

It is recommended not to defines rings as R=QQ[x,y][a,b,c] when the variables
to eliminate are '{x,y}'. In this case, see flattenRing (Macaulay2Doc),
for passing from $R=QQ[x,y][a,b,c]$ to
QQ[x,y,a,b,c].
+------------------------------------------------+
|i1 : R=QQ[a,b,c,x,y]                            |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : f1 = a*x^2+b*x*y+c*y^2                     |
|                                                |
|        2              2                        |
|o2 = a*x  + b*x*y + c*y                         |
|                                                |
|o2 : R                                          |
+------------------------------------------------+
|i3 : f2 = 2*a*x+b*y                             |
|                                                |
|o3 = 2a*x + b*y                                 |
|                                                |
|o3 : R                                          |
+------------------------------------------------+
|i4 : M = matrix{{f1,f2}}                        |
|                                                |
|o4 = | ax2+bxy+cy2 2ax+by |                     |
|                                                |
|             1      2                           |
|o4 : Matrix R  <-- R                            |
+------------------------------------------------+
|i5 : l = {x,y}                                  |
|                                                |
|o5 = {x, y}                                     |
|                                                |
|o5 : List                                       |
+------------------------------------------------+
|i6 : dHPM = listDetComplex (2,l,koszulComplex M)|
|                                                |
|           2     2                              |
|o6 = {- a*b  + 4a c, 1}                         |
|                                                |
|o6 : List                                       |
+------------------------------------------------+
|i7 : dHPM = listDetComplex (3,l,koszulComplex M)|
|                                                |
|           2      2 2                           |
|o7 = {- a*b c + 4a c , c}                       |
|                                                |
|o7 : List                                       |
+------------------------------------------------+
+-----------------------------------------------------------------------------+
|i8 : R=QQ[a,b,c,d,e,f,g,h,i,x,y,z]                                           |
|                                                                             |
|o8 = R                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : f1 = a*x+b*y+c*z                                                        |
|                                                                             |
|o9 = a*x + b*y + c*z                                                         |
|                                                                             |
|o9 : R                                                                       |
+-----------------------------------------------------------------------------+
|i10 : f2 = d*x+e*y+f*z                                                       |
|                                                                             |
|o10 = d*x + e*y + f*z                                                        |
|                                                                             |
|o10 : R                                                                      |
+-----------------------------------------------------------------------------+
|i11 : f3 = g*x+h*y+i*z                                                       |
|                                                                             |
|o11 = g*x + h*y + i*z                                                        |
|                                                                             |
|o11 : R                                                                      |
+-----------------------------------------------------------------------------+
|i12 : M = matrix{{f1,f2,f3}}                                                 |
|                                                                             |
|o12 = | ax+by+cz dx+ey+fz gx+hy+iz |                                         |
|                                                                             |
|              1      3                                                       |
|o12 : Matrix R  <-- R                                                        |
+-----------------------------------------------------------------------------+
|i13 : l = {x,y,z}                                                            |
|                                                                             |
|o13 = {x, y, z}                                                              |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : dHPM = listDetComplex (1,l,koszulComplex M, Strategy => Exact)         |
|                                                                             |
|o14 = {- c*e*g + b*f*g + c*d*h - a*f*h - b*d*i + a*e*i, 1, 1}                |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
|i15 : setRandomSeed 0                                                        |
| -- setting random seed to 0                                                 |
|                                                                             |
|o15 = 0                                                                      |
+-----------------------------------------------------------------------------+
|i16 : dHPM = listDetComplex (2,l,koszulComplex M, Strategy => Numeric)       |
|                                                                             |
|        3 2        2         2   2     3           2           2             |
|o16 = {c e g - 2b*c e*f*g + b c*f g - c d*e*h + b*c d*f*h + a*c e*f*h -      |
|      -----------------------------------------------------------------------|
|             2       2           2 2     2                          2        |
|      a*b*c*f h + b*c d*e*i - a*c e i - b c*d*f*i + a*b*c*e*f*i, - c e +     |
|      -----------------------------------------------------------------------|
|      b*c*f, 1}                                                              |
|                                                                             |
|o16 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * degHomPolMap -- return the base of monomials in a
    subset of variables, and the matrix of coefficients of a morphism of free
    modules f:R(d1)+...+R(dn)->R_d with respect to these variables
  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.

Ways to use listDetComplex:
===========================

  * "listDetComplex(ZZ,List,Complex)"

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

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

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

The source of this document is in EliminationMatrices.m2:1017:0.

listDetComplex(...,Strategy=>...) -- choose between Exact and Numeric algorithms
********************************************************************************

  * Usage:
        listDetComplex(d,v,C, Strategy => s)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
      * s, a symbol (Macaulay2Doc), either Exact or Numeric
  * Consequences:
      * If s is Exact, then therank (Macaulay2Doc),
        algorithms is used computing minors; if s is Numeric,
        then numerical rank computation is used, this is, all coefficients are
        evaluated in the ground field before computing ranks.

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

See Exact,is the default Strategy.

See also
========

  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * detComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "eliminationMatrix(...,Strategy=>...)" -- see eliminationMatrix,
    -- returns a matrix that represents the image of the map
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * epicResolutionMap(...,Strategy=>...) (missing documentation)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * listDetComplex(...,Strategy=>...)
    -- choose between
    Exact and Numeric algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * maxCol(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * maxMinor(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * minorsComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * pruneComplex(...,Strategy=>...) (Complexes)
    -- Whether to
    use the methods in the package or C++ algorithms in the engine
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * "freeResolution(...,Strategy=>...)" -- see Strategies for free resolutions (Complexes),
    -- overview of the
    different algorithms for computing free resolutions
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: listDetComplex, -- This function calculates
    the list with the determinants of some minors of the maps of a graded
    Complex with respect to a subset of the variables of the polynomial ring in
    a fixed degree.
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1085:0.

Macaulay -- Strategy for eliminationMatrix.
*******************************************

  * Usage:
        eliminationMatrix(..., Strategy => Macaulay)
  * Consequences:
      * Let
      * $f_1,...,f_n$
      *  be a polynomials two groups of variables
      * $X_1,...,X_n$
      *  and
      * $a_1,...,a_s$
      *  and such that
      * $f_1,...,f_n$
      *  are homogeneous polynomials with respect to the variables
      * $X_1,...,X_n$
      * . This function returns a matrix which is generically (in terms of the
        parameters
      * $a_1,...,a_s$
      * ) surjective such that the gcd of its maximal minors is the Macaulay
        resultant of
      * $f_1,...,f_n$
      * .

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

The object Macaulay, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1551:0.

macaulayFormula -- returns two matrices such that the ratio of their determinants is the Macaulay resultant
***********************************************************************************************************

  * Usage:
        macaulayFormula(v,m)
  * Inputs:
      * v, a list (Macaulay2Doc), a list of n variables such that
        the polynomials $f_1,...,f_n$ are homogeneous with respect to these
        variables
      * m, a matrix (Macaulay2Doc), a single row matrix with
        polynomials $f_1,...,f_n$
  * Outputs:
      * a list (Macaulay2Doc), a list of two matrices such that the
        ratio of their determinants is the Macaulay resultant of f_1,...,f_n
        with respect to the variables v

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

Let $f_1,...,f_n$ be a polynomials two groups of variables $X_1,...,X_n$ and
$a_1,...,a_s$ and such that $f_1,...,f_n$ are homogeneous polynomials with
respect to the variables $X_1,...,X_n$. This function returns two matrices M1
and M2 such that $det(D_1)/det(D_2)$ is the Macaulay resultant of $f_1,...,f_n$
providing det(D_2) is nonzero.

Remark: if D2 is the empty matrix, its determinant has to be understood as 1
(and not zero, which is the case in Macaulay2 since the empty matrix is
identified to the zero.
+-----------------------------------+
|i1 : R=QQ[a..i,x,y,z]              |
|                                   |
|o1 = R                             |
|                                   |
|o1 : PolynomialRing                |
+-----------------------------------+
|i2 : f1 = a*x+b*y+c*z              |
|                                   |
|o2 = a*x + b*y + c*z               |
|                                   |
|o2 : R                             |
+-----------------------------------+
|i3 : f2 = d*x+e*y+f*z              |
|                                   |
|o3 = d*x + e*y + f*z               |
|                                   |
|o3 : R                             |
+-----------------------------------+
|i4 : f3 = g*x+h*y+i*z              |
|                                   |
|o4 = g*x + h*y + i*z               |
|                                   |
|o4 : R                             |
+-----------------------------------+
|i5 : M = matrix{{f1,f2,f3}}        |
|                                   |
|o5 = | ax+by+cz dx+ey+fz gx+hy+iz ||
|                                   |
|             1      3              |
|o5 : Matrix R  <-- R               |
+-----------------------------------+
|i6 : l = {x,y,z}                   |
|                                   |
|o6 = {x, y, z}                     |
|                                   |
|o6 : List                          |
+-----------------------------------+
|i7 : MR = macaulayFormula (l,M)    |
|                                   |
|o7 = ({1} | a d g |, 0)            |
|      {1} | b e h |                |
|      {1} | c f i |                |
|                                   |
|o7 : Sequence                      |
+-----------------------------------+

See also
========

  * eliminationMatrix -- returns a matrix that
    represents the image of the map
  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.

Ways to use macaulayFormula:
============================

  * "macaulayFormula(List,Matrix)"

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

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

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

The source of this document is in EliminationMatrices.m2:1197:0.

mapsComplex -- This function calculates the maps of a graded Complex with respect to a subset of the variables of the polynomial ring in a fixed degree.
********************************************************************************************************************************************************

  * Usage:
        mapsOfTheComplex = mapsComplex(d, v, C)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
  * Outputs:
      * a list (Macaulay2Doc), a list of matrices

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

This function calculates the maps of a graded Complex with respect to a subset
of the variables of the polynomial ring in a fixed degree.

The input Complex needs to be an exact complex of free modules over a
polynomial ring. The polynomial ring must contain the list v as variables.

It is recommended not to define rings as R=QQ[x,y][a,b,c] when the variables to
eliminate are '{x,y}'. In this case, see flattenRing (Macaulay2Doc),
for passing from $R=QQ[x,y][a,b,c]$ to
QQ[x,y,a,b,c].
+---------------------------------------------+
|i1 : R=QQ[a,b,c,x,y]                         |
|                                             |
|o1 = R                                       |
|                                             |
|o1 : PolynomialRing                          |
+---------------------------------------------+
|i2 : f1 = a*x^2+b*x*y+c*y^2                  |
|                                             |
|        2              2                     |
|o2 = a*x  + b*x*y + c*y                      |
|                                             |
|o2 : R                                       |
+---------------------------------------------+
|i3 : f2 = 2*a*x+b*y                          |
|                                             |
|o3 = 2a*x + b*y                              |
|                                             |
|o3 : R                                       |
+---------------------------------------------+
|i4 : M = matrix{{f1,f2}}                     |
|                                             |
|o4 = | ax2+bxy+cy2 2ax+by |                  |
|                                             |
|             1      2                        |
|o4 : Matrix R  <-- R                         |
+---------------------------------------------+
|i5 : l = {x,y}                               |
|                                             |
|o5 = {x, y}                                  |
|                                             |
|o5 : List                                    |
+---------------------------------------------+
|i6 : dHPM = mapsComplex (2,l,koszulComplex M)|
|                                             |
|o6 = {{2} | a 2a 0  |, 0}                    |
|      {2} | b b  2a |                        |
|      {2} | c 0  b  |                        |
|                                             |
|o6 : List                                    |
+---------------------------------------------+
|i7 : dHPM = mapsComplex (3,l,koszulComplex M)|
|                                             |
|o7 = {{3} | a 0 2a 0  0  |, {1} | -2a |}     |
|      {3} | b a b  2a 0  |  {1} | -b  |      |
|      {3} | c b 0  b  2a |  {2} | a   |      |
|      {3} | 0 c 0  0  b  |  {2} | b   |      |
|                            {2} | c   |      |
|                                             |
|o7 : List                                    |
+---------------------------------------------+
+------------------------------------------------------+
|i8 : R=QQ[a,b,c,d,e,f,g,h,i,x,y,z]                    |
|                                                      |
|o8 = R                                                |
|                                                      |
|o8 : PolynomialRing                                   |
+------------------------------------------------------+
|i9 : f1 = a*x+b*y+c*z                                 |
|                                                      |
|o9 = a*x + b*y + c*z                                  |
|                                                      |
|o9 : R                                                |
+------------------------------------------------------+
|i10 : f2 = d*x+e*y+f*z                                |
|                                                      |
|o10 = d*x + e*y + f*z                                 |
|                                                      |
|o10 : R                                               |
+------------------------------------------------------+
|i11 : f3 = g*x+h*y+i*z                                |
|                                                      |
|o11 = g*x + h*y + i*z                                 |
|                                                      |
|o11 : R                                               |
+------------------------------------------------------+
|i12 : M = matrix{{f1,f2,f3}}                          |
|                                                      |
|o12 = | ax+by+cz dx+ey+fz gx+hy+iz |                  |
|                                                      |
|              1      3                                |
|o12 : Matrix R  <-- R                                 |
+------------------------------------------------------+
|i13 : l = {x,y,z}                                     |
|                                                      |
|o13 = {x, y, z}                                       |
|                                                      |
|o13 : List                                            |
+------------------------------------------------------+
|i14 : dHPM = mapsComplex (1,l,koszulComplex M)        |
|                                                      |
|o14 = {{1} | a d g |, 0, 0}                           |
|       {1} | b e h |                                  |
|       {1} | c f i |                                  |
|                                                      |
|o14 : List                                            |
+------------------------------------------------------+
|i15 : dHPM = mapsComplex (2,l,koszulComplex M)        |
|                                                      |
|o15 = {{2} | a 0 0 d 0 0 g 0 0 |, {1} | -d -g 0  |, 0}|
|       {2} | b a 0 e d 0 h g 0 |  {1} | -e -h 0  |    |
|       {2} | c 0 a f 0 d i 0 g |  {1} | -f -i 0  |    |
|       {2} | 0 b 0 0 e 0 0 h 0 |  {1} | a  0  -g |    |
|       {2} | 0 c b 0 f e 0 i h |  {1} | b  0  -h |    |
|       {2} | 0 0 c 0 0 f 0 0 i |  {1} | c  0  -i |    |
|                                  {1} | 0  a  d  |    |
|                                  {1} | 0  b  e  |    |
|                                  {1} | 0  c  f  |    |
|                                                      |
|o15 : List                                            |
+------------------------------------------------------+

See also
========

  * degHomPolMap -- return the base of monomials in a
    subset of variables, and the matrix of coefficients of a morphism of free
    modules f:R(d1)+...+R(dn)->R_d with respect to these variables
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.
  * minorsComplex -- calculate some minors of the maps of
    a graded Complex in a subset of variables and fixed degree
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.

Ways to use mapsComplex:
========================

  * "mapsComplex(ZZ,List,Complex)"

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

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

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

The source of this document is in EliminationMatrices.m2:930:0.

maxCol -- Returns a submatrix form by a maximal set of linear independent columns.
**********************************************************************************

  * Usage:
        MM = maxCol(m)
  * Inputs:
      * m, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value null, choose between Exact and Numeric algorithms
  * Outputs:
      * M, a matrix (Macaulay2Doc),
      * c, a list (Macaulay2Doc),

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

 From a given m x n - Matrix of rank r, see maxCol, returns a
submatrix M form by a maximal set of linear independent columns, and the list
of columns c chosen.
+-------------------------------------------------+
|i1 : M = matrix {{1,2,3},{1,2,3},{4,5,6},{4,5,6}}|
|                                                 |
|o1 = | 1 2 3 |                                   |
|     | 1 2 3 |                                   |
|     | 4 5 6 |                                   |
|     | 4 5 6 |                                   |
|                                                 |
|              4       3                          |
|o1 : Matrix ZZ  <-- ZZ                           |
+-------------------------------------------------+
|i2 : maxCol M;                                   |
+-------------------------------------------------+

NOTE: because of the necessity of rank (Macaulay2Doc), the base
field need to be QQ for doing generic evaluation. If not, one gets the message:
expected an affine ring (consider Generic=>true to work over QQ).
+-------------------------------------------------+
|i3 : R=QQ[a..g]                                  |
|                                                 |
|o3 = R                                           |
|                                                 |
|o3 : PolynomialRing                              |
+-------------------------------------------------+
|i4 : M = matrix {{a,a,b},{c,c,d},{e,e,f},{g,g,g}}|
|                                                 |
|o4 = | a a b |                                   |
|     | c c d |                                   |
|     | e e f |                                   |
|     | g g g |                                   |
|                                                 |
|             4      3                            |
|o4 : Matrix R  <-- R                             |
+-------------------------------------------------+
|i5 : maxCol M                                    |
|                                                 |
|o5 = {| a b |, {0, 2}}                           |
|      | c d |                                    |
|      | e f |                                    |
|      | g g |                                    |
|                                                 |
|o5 : List                                        |
+-------------------------------------------------+

See also
========

  * maxMinor -- Returns a maximal minor of the matrix of full
    rank.
  * rank (Macaulay2Doc) -- compute the rank

Ways to use maxCol:
===================

  * "maxCol(Matrix)"

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

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

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

The source of this document is in EliminationMatrices.m2:1115:0.

maxCol(...,Strategy=>...) -- choose between Exact and Numeric algorithms
************************************************************************

  * Usage:
        maxCol(M, Strategy => s)
  * Inputs:
      * m, a matrix (Macaulay2Doc), a matrix (usually with
        coefficients in a polynomial ring)
      * s, a symbol (Macaulay2Doc), either Exact or Numeric
  * Consequences:
      * If s is Exact, then therank (Macaulay2Doc),
        algorithms is used computing minors; if s is Numeric,
        then numerical rank computation is used, this is, all coefficients are
        evaluated in the ground field before computing ranks.

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

See Exact,is the default Strategy.

See also
========

  * maxMinor -- Returns a maximal minor of the matrix of full
    rank.

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * detComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "eliminationMatrix(...,Strategy=>...)" -- see eliminationMatrix,
    -- returns a matrix that represents the image of the map
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * epicResolutionMap(...,Strategy=>...) (missing documentation)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * listDetComplex(...,Strategy=>...)
    -- choose between
    Exact and Numeric algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * maxCol(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * maxMinor(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * minorsComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * pruneComplex(...,Strategy=>...) (Complexes)
    -- Whether to
    use the methods in the package or C++ algorithms in the engine
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * "freeResolution(...,Strategy=>...)" -- see Strategies for free resolutions (Complexes),
    -- overview of the
    different algorithms for computing free resolutions
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: maxCol, -- Returns a submatrix form by a maximal
    set of linear independent columns.
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1165:0.

maxMinor -- Returns a maximal minor of the matrix of full rank.
***************************************************************

  * Usage:
        MM = maxMinor(Mat)
  * Inputs:
      * m, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value null, choose between Exact and Numeric algorithms
  * Outputs:
      * a matrix (Macaulay2Doc),

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

 From a given m x n - Matrix of rank r, see maxMinor, returns an r
x r full rank Matrix. This method uses twice the method maxCol,
by transposing twice.
+-----------------------------------------------+
|i1 : M=matrix {{1,2,3},{1,2,3},{4,5,6},{4,5,6}}|
|                                               |
|o1 = | 1 2 3 |                                 |
|     | 1 2 3 |                                 |
|     | 4 5 6 |                                 |
|     | 4 5 6 |                                 |
|                                               |
|              4       3                        |
|o1 : Matrix ZZ  <-- ZZ                         |
+-----------------------------------------------+
|i2 : maxMinor M                                |
|                                               |
|o2 = | 1 2 |                                   |
|     | 4 5 |                                   |
|                                               |
|              2       2                        |
|o2 : Matrix ZZ  <-- ZZ                         |
+-----------------------------------------------+

NOTE: because of the necessity of rank (Macaulay2Doc), the base
field need to be QQ for doing generic evaluation. If not, one gets the message:
expected an affine ring (consider Generic=>true to work over QQ).
+-----------------------------------------------+
|i3 : R=QQ[a..g]                                |
|                                               |
|o3 = R                                         |
|                                               |
|o3 : PolynomialRing                            |
+-----------------------------------------------+
|i4 : M=matrix {{a,a,b},{c,c,d},{e,e,f},{g,g,g}}|
|                                               |
|o4 = | a a b |                                 |
|     | c c d |                                 |
|     | e e f |                                 |
|     | g g g |                                 |
|                                               |
|             4      3                          |
|o4 : Matrix R  <-- R                           |
+-----------------------------------------------+
|i5 : maxMinor M                                |
|                                               |
|o5 = | a b |                                   |
|     | c d |                                   |
|                                               |
|             2      2                          |
|o5 : Matrix R  <-- R                           |
+-----------------------------------------------+

See also
========

  * maxCol -- Returns a submatrix form by a maximal set of
    linear independent columns.
  * rank (Macaulay2Doc) -- compute the rank

Ways to use maxMinor:
=====================

  * "maxMinor(Matrix)"

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

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

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

The source of this document is in EliminationMatrices.m2:1143:0.

maxMinor(...,Strategy=>...) -- choose between Exact and Numeric algorithms
**************************************************************************

  * Usage:
        maxMinor(M, Strategy => s)
  * Inputs:
      * m, a matrix (Macaulay2Doc), a matrix (usually with
        coefficients in a polynomial ring)
      * s, a symbol (Macaulay2Doc), either Exact or Numeric
  * Consequences:
      * If s is Exact, then therank (Macaulay2Doc),
        algorithms is used computing minors; if s is Numeric,
        then numerical rank computation is used, this is, all coefficients are
        evaluated in the ground field before computing ranks.

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

See Exact,is the default Strategy.

See also
========

  * maxCol -- Returns a submatrix form by a maximal set of
    linear independent columns.

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * detComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "eliminationMatrix(...,Strategy=>...)" -- see eliminationMatrix,
    -- returns a matrix that represents the image of the map
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * epicResolutionMap(...,Strategy=>...) (missing documentation)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * listDetComplex(...,Strategy=>...)
    -- choose between
    Exact and Numeric algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * maxCol(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * maxMinor(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * minorsComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * pruneComplex(...,Strategy=>...) (Complexes)
    -- Whether to
    use the methods in the package or C++ algorithms in the engine
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * "freeResolution(...,Strategy=>...)" -- see Strategies for free resolutions (Complexes),
    -- overview of the
    different algorithms for computing free resolutions
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: maxMinor, -- Returns a maximal minor of the
    matrix of full rank.
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1165:0.

minorsComplex -- calculate some minors of the maps of a graded Complex in a subset of variables and fixed degree
****************************************************************************************************************

  * Usage:
        minorsOfTheComplex = minorsComplex(d,v,C)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * Strategy, =>
        ..., default value null, choose between Exact and Numeric algorithms
  * Outputs:
      * a list (Macaulay2Doc), a list of square (full-rank)
        matrices

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

This function calculates some minors of the maps of a graded Complex with
respect to a subset of the variables of the polynomial ring in a fixed degree.
The choice of the minors is according to the construction of the determinant of
a complex

The input Complex needs to be an exact complex of free modules over a
polynomial ring. The polynomial ring must contain the list v as variables.

It is recommended not to defines rings as R=QQ[x,y][a,b,c] when the variables
to eliminate are '{x,y}'. In this case, see flattenRing (Macaulay2Doc),
for passing from $R=QQ[x,y][a,b,c]$ to
QQ[x,y,a,b,c].
+-----------------------------------------------+
|i1 : R=QQ[a,b,c,x,y]                           |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : f1 = a*x^2+b*x*y+c*y^2                    |
|                                               |
|        2              2                       |
|o2 = a*x  + b*x*y + c*y                        |
|                                               |
|o2 : R                                         |
+-----------------------------------------------+
|i3 : f2 = 2*a*x+b*y                            |
|                                               |
|o3 = 2a*x + b*y                                |
|                                               |
|o3 : R                                         |
+-----------------------------------------------+
|i4 : M = matrix{{f1,f2}}                       |
|                                               |
|o4 = | ax2+bxy+cy2 2ax+by |                    |
|                                               |
|             1      2                          |
|o4 : Matrix R  <-- R                           |
+-----------------------------------------------+
|i5 : l = {x,y}                                 |
|                                               |
|o5 = {x, y}                                    |
|                                               |
|o5 : List                                      |
+-----------------------------------------------+
|i6 : dHPM = minorsComplex (2,l,koszulComplex M)|
|                                               |
|o6 = {{2} | a 2a 0  |, 0}                      |
|      {2} | b b  2a |                          |
|      {2} | c 0  b  |                          |
|                                               |
|o6 : List                                      |
+-----------------------------------------------+
|i7 : dHPM = minorsComplex (3,l,koszulComplex M)|
|                                               |
|o7 = {{3} | a 0 2a 0  |, {2} | c |}            |
|      {3} | b a b  2a |                        |
|      {3} | c b 0  b  |                        |
|      {3} | 0 c 0  0  |                        |
|                                               |
|o7 : List                                      |
+-----------------------------------------------+
+---------------------------------------------------------------------+
|i8 : R=QQ[a,b,c,d,e,f,g,h,i,x,y,z]                                   |
|                                                                     |
|o8 = R                                                               |
|                                                                     |
|o8 : PolynomialRing                                                  |
+---------------------------------------------------------------------+
|i9 : f1 = a*x+b*y+c*z                                                |
|                                                                     |
|o9 = a*x + b*y + c*z                                                 |
|                                                                     |
|o9 : R                                                               |
+---------------------------------------------------------------------+
|i10 : f2 = d*x+e*y+f*z                                               |
|                                                                     |
|o10 = d*x + e*y + f*z                                                |
|                                                                     |
|o10 : R                                                              |
+---------------------------------------------------------------------+
|i11 : f3 = g*x+h*y+i*z                                               |
|                                                                     |
|o11 = g*x + h*y + i*z                                                |
|                                                                     |
|o11 : R                                                              |
+---------------------------------------------------------------------+
|i12 : M = matrix{{f1,f2,f3}}                                         |
|                                                                     |
|o12 = | ax+by+cz dx+ey+fz gx+hy+iz |                                 |
|                                                                     |
|              1      3                                               |
|o12 : Matrix R  <-- R                                                |
+---------------------------------------------------------------------+
|i13 : l = {x,y,z}                                                    |
|                                                                     |
|o13 = {x, y, z}                                                      |
|                                                                     |
|o13 : List                                                           |
+---------------------------------------------------------------------+
|i14 : dHPM = minorsComplex (1,l,koszulComplex M, Strategy => Exact)  |
|                                                                     |
|o14 = {{1} | a d g |, 0, 0}                                          |
|       {1} | b e h |                                                 |
|       {1} | c f i |                                                 |
|                                                                     |
|o14 : List                                                           |
+---------------------------------------------------------------------+
|i15 : setRandomSeed 0                                                |
| -- setting random seed to 0                                         |
|                                                                     |
|o15 = 0                                                              |
+---------------------------------------------------------------------+
|i16 : dHPM = minorsComplex (2,l,koszulComplex M, Strategy => Numeric)|
|                                                                     |
|o16 = {{2} | a 0 0 d 0 g |, {1} | c 0 -i |, 0}                       |
|       {2} | b a 0 e d h |  {1} | 0 b e  |                           |
|       {2} | c 0 a f 0 i |  {1} | 0 c f  |                           |
|       {2} | 0 b 0 0 e 0 |                                           |
|       {2} | 0 c b 0 f 0 |                                           |
|       {2} | 0 0 c 0 0 0 |                                           |
|                                                                     |
|o16 : List                                                           |
+---------------------------------------------------------------------+

See also
========

  * degHomPolMap -- return the base of monomials in a
    subset of variables, and the matrix of coefficients of a morphism of free
    modules f:R(d1)+...+R(dn)->R_d with respect to these variables
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.
  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * mapsComplex -- This function calculates the maps of a
    graded Complex with respect to a subset of the variables of the polynomial
    ring in a fixed degree.

Ways to use minorsComplex:
==========================

  * "minorsComplex(ZZ,List,Complex)"

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

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

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

The source of this document is in EliminationMatrices.m2:974:0.

minorsComplex(...,Strategy=>...) -- choose between Exact and Numeric algorithms
*******************************************************************************

  * Usage:
        minorsComplex(d,v,C, Strategy => s)
  * Inputs:
      * d, an integer (Macaulay2Doc), integer corresponding to the
        degree of the strand of the chain complex.
      * v, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for elimination
      * C, a complex (Complexes), a chain complex of free
        modules over a polynomial ring
      * s, a symbol (Macaulay2Doc), either Exact or Numeric
  * Consequences:
      * If s is Exact, then therank (Macaulay2Doc),
        algorithms is used computing minors; if s is Numeric,
        then numerical rank computation is used, this is, all coefficients are
        evaluated in the ground field before computing ranks.

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

See Exact,is the default Strategy.

See also
========

  * detComplex -- This function calculates the determinant
    of a graded Complex with respect to a subset of the variables of the
    polynomial ring in a fixed degree.
  * listDetComplex -- This function calculates the list
    with the determinants of some minors of the maps of a graded Complex with
    respect to a subset of the variables of the polynomial ring in a fixed
    degree.

Functions with optional argument named Strategy:
================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * annihilator(...,Strategy=>...) (missing documentation)
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * detComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "eliminationMatrix(...,Strategy=>...)" -- see eliminationMatrix,
    -- returns a matrix that represents the image of the map
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * epicResolutionMap(...,Strategy=>...) (missing documentation)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hilbertFunction(...,Strategy=>...) (missing documentation)
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * kernel(...,Strategy=>...) (Macaulay2Doc)
    -- strategy for
    Groebner Basis computations used in kernel computations
  * listDetComplex(...,Strategy=>...)
    -- choose between
    Exact and Numeric algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * maxCol(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * maxMinor(...,Strategy=>...)
    -- choose between Exact and
    Numeric algorithms
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * minorsComplex(...,Strategy=>...)
    -- choose between Exact
    and Numeric algorithms
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * pruneComplex(...,Strategy=>...) (Complexes)
    -- Whether to
    use the methods in the package or C++ algorithms in the engine
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * "freeResolution(...,Strategy=>...)" -- see Strategies for free resolutions (Complexes),
    -- overview of the
    different algorithms for computing free resolutions
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

Further information
===================

  * Default value: null
  * Function: minorsComplex, -- calculate some minors of
    the maps of a graded Complex in a subset of variables and fixed degree
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in EliminationMatrices.m2:1085:0.

Numeric -- Strategy for functions that uses rank computation.
*************************************************************

  * Usage:
        Strategy => Numeric
  * Consequences:
      * If 'Numeric' Strategy is used, then numerical rank computation is used
        instead of
      * Exact -- Strategy for functions that uses rank
        computation.
      *  rank computation. Precisely, all coefficients are evaluated in the
        ground field before computing ranks.

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

The object Numeric, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1528:0.

regularityVar -- computes the Castelnuovo-Mumford regularity of homogeneous ideals in terms of Betti numbers, with respect to some of the variables of the ring
***************************************************************************************************************************************************************

  * Usage:
        regularityVar(l,I)
  * Inputs:
      * l, a list (Macaulay2Doc), list of variables of the
        polynomial ring R to take into account for computing the
        Castelnuovo-Mumford regularity
      * I, an ideal (Macaulay2Doc), ideal of a polynomial ring

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

regularityVar computes the Castelnuovo-Mumford regularity of homogeneous ideals
in a polynomial ring by computing the shifts and degrees of generators in a
minimal free resolution of the homogeneous ideal.

The list of variables l contains the variables of the ring having degree 1.
Those variables on the ring not in l have automatically degree 0, as well as
the elements on the coefficient ring
+--------------------------------------------------------------+
|i1 : R=QQ[a..i,x,y,z]                                         |
|                                                              |
|o1 = R                                                        |
|                                                              |
|o1 : PolynomialRing                                           |
+--------------------------------------------------------------+
|i2 : f1 = a*x+b*y+c*z                                         |
|                                                              |
|o2 = a*x + b*y + c*z                                          |
|                                                              |
|o2 : R                                                        |
+--------------------------------------------------------------+
|i3 : f2 = d*x+e*y+f*z                                         |
|                                                              |
|o3 = d*x + e*y + f*z                                          |
|                                                              |
|o3 : R                                                        |
+--------------------------------------------------------------+
|i4 : f3 = g*x+h*y+i*z                                         |
|                                                              |
|o4 = g*x + h*y + i*z                                          |
|                                                              |
|o4 : R                                                        |
+--------------------------------------------------------------+
|i5 : I = ideal(f1,f2,f3)                                      |
|                                                              |
|o5 = ideal (a*x + b*y + c*z, d*x + e*y + f*z, g*x + h*y + i*z)|
|                                                              |
|o5 : Ideal of R                                               |
+--------------------------------------------------------------+
|i6 : l = {x,y,z}                                              |
|                                                              |
|o6 = {x, y, z}                                                |
|                                                              |
|o6 : List                                                     |
+--------------------------------------------------------------+
|i7 : regularityVar (l,I)                                      |
|                                                              |
|o7 = 1                                                        |
+--------------------------------------------------------------+

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring
  * freeResolution (Complexes) -- compute a free
    resolution of a module or ideal

Ways to use regularityVar:
==========================

  * "regularityVar(List,Ideal)"

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

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

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

The source of this document is in EliminationMatrices.m2:1636:0.

Sylvester -- Strategy for eliminationMatrix.
********************************************

  * Usage:
        eliminationMatrix(..., Strategy => Sylvester)
  * Consequences:
      * Invokes the method
      * sylvesterMatrix (Elimination)

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

The object Sylvester, is a symbol (Macaulay2Doc).

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

The source of this document is in EliminationMatrices.m2:1562:0.