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

EliminationTemplates -- zero-dimensional polynomial solvers based on linear algebra
***********************************************************************************

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

EliminationTemplates is a package that supports solvers for the following
problem: given a zero-dimensional radical ideal $I \subset R := \mathbb{C}
[x_1, \ldots , x_n]$, find approximate values for the isolated solutions $(p_1,
\ldots , p_n ) \in V_{\mathbb{C}} (I).$ The main applications occur when the
ideal $I$ occur in a parametric family of problems with similar structure.

Following the references below, the package is geared twowards implementing a
"two-stage" approach, consisting of (1) offline stage and (2) an online stage.

In the offline stage, the structure of a "template matrix" for $I$ is
determined using Groebner basis computations.

In the online stage, prior knowledge of the template matrix can be used to
construct a multiplication matrix for the quotient ring $R/I.$ From this
multiplication matrix, solutions can be extracted using only linear algebra.

References
==========

  * Optimizing Elimination Templates by Greedy Parameter Search,
    Martyushev-Vrablikova-Pajdla CVPR 2022
  * Efficient solvers for minimal problems by syzygy-based reduction,
    Larsson-Oskarsson-Astrom CVPR 2017

Authors
=======

  * Manav Batavia (see  ) <manavbatavia@gmail.com>
  * Cheng Chen (see  ) <chengchen@math.wisc.edu>
  * Wanchun / Rosie Shen (see  ) <wshen@math.harvard.edu>
  * Anna Natalie Chlopecki (see  ) <achlopec@purdue.edu>
  * Tim Duff (see https://timduff35.github.io/timduff35/ ) <tduff@missouri.edu>
  * Will Huang (see  ) <williamhuang5120@gmail.com>
  * Aolong Li (see  ) <lial0921.miu@gmail.com>

Version
=======

This documentation describes version 1 of EliminationTemplates, released April
30, 2026.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{EliminationTemplatesSource,                                            |
|  title = {{EliminationTemplates: A \emph{Macaulay2} package. Version~1}},   |
|  author = {Manav Batavia and Cheng Chen and Wanchun / Rosie Shen and Anna   |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    ""}                                                                      |
|}                                                                            |
|-----------------------------------------------------------------------------|
|Natalie Chlopecki and Tim Duff and Will Huang and Aolong Li},                |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * EliminationTemplate -- type for elimination
        template objects
  * Functions and commands
      * actionVariable -- returns the action variable
        associated to the elimination template
      * copyTemplate -- copies EliminationTemplate object
      * eliminationTemplate -- constructor for an
        EliminationTemplate object
      * getActionMatrix -- computes or retrieves a
        template's action matrix
      * getTemplate -- construct the shifts and monomial
        partition for an elimination template
      * getTemplateMatrix -- computes template matrix
      * templateSolve -- polynomial system solver using
        elimination templates
  * Methods
      * "actionVariable(EliminationTemplate)" -- see actionVariable,
        -- returns the action variable associated to the
        elimination template
      * basis(EliminationTemplate), --
        access the quotient basis of an EliminationTemplate
      * "copyTemplate(EliminationTemplate,Ideal)" -- see copyTemplate,
        -- copies EliminationTemplate object
      * "eliminationTemplate(RingElement,Ideal)" -- see
        eliminationTemplate, -- constructor for an
        EliminationTemplate object
      * "getActionMatrix(EliminationTemplate)" -- see getActionMatrix,
        -- computes or retrieves a template's action matrix
      * "getTemplate(EliminationTemplate)" -- see getTemplate,
        -- construct the shifts and monomial partition for an
        elimination template
      * "getTemplateMatrix(EliminationTemplate)" -- see
        getTemplateMatrix, -- computes template matrix
      * "getTemplateMatrix(RingElement,Matrix,Ideal)" -- see
        getTemplateMatrix, -- computes template matrix
      * ideal(EliminationTemplate), --
        access the ideal of an EliminationTemplate
      * net(EliminationTemplate), --
        display an EliminationTemplate
      * "templateSolve(EliminationTemplate)" -- see templateSolve,
        -- polynomial system solver using elimination templates
      * "templateSolve(Ideal)" -- see templateSolve, --
        polynomial system solver using elimination templates
      * "templateSolve(RingElement,Ideal)" -- see templateSolve,
        -- polynomial system solver using elimination templates
  * Symbols
      * "AdjustParams" -- see getTemplate, -- construct the
        shifts and monomial partition for an elimination template

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

The object EliminationTemplates, is a package (Macaulay2Doc),
defined in EliminationTemplates.m2, with auxiliary
files in EliminationTemplates/.

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

The source of this document is in EliminationTemplates.m2:804:0.

actionVariable -- returns the action variable associated to the elimination template
************************************************************************************

  * Usage:
        actionVariable(E)
  * Inputs:
      * E, an instance of the type EliminationTemplate,
        the elimination template for this problem
  * Outputs:
      * a, a ring element (Macaulay2Doc), the action
        variable associated to E

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

This method outputs the action variable associated to the inputted elimination
template E.

+--------------------------------------------+
|i1 : R = QQ[x,y]                            |
|                                            |
|o1 = R                                      |
|                                            |
|o1 : PolynomialRing                         |
+--------------------------------------------+
|i2 : I = ideal(x^4+x*y+y^2-3, x^2*y+y^3-2)  |
|                                            |
|             4          2       2     3     |
|o2 = ideal (x  + x*y + y  - 3, x y + y  - 2)|
|                                            |
|o2 : Ideal of R                             |
+--------------------------------------------+
|i3 : E = eliminationTemplate(x,I)           |
|                                            |
|o3 =  action variable: x                    |
|                                            |
|o3 : EliminationTemplate                    |
+--------------------------------------------+
|i4 : actionVariable(E)                      |
|                                            |
|o4 = x                                      |
|                                            |
|o4 : R                                      |
+--------------------------------------------+

See also
========

  * EliminationTemplate -- type for elimination
    template objects

Ways to use actionVariable:
===========================

  * "actionVariable(EliminationTemplate)"

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

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

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

The source of this document is in EliminationTemplates.m2:1162:0.

basis(EliminationTemplate) -- access the quotient basis of an EliminationTemplate
*********************************************************************************

  * Function: basis (Macaulay2Doc),
  * Usage:
        basis E
  * Inputs:
      * E, an instance of the type EliminationTemplate,
  * Optional inputs (Macaulay2Doc),:
      * Degree => ..., default value null
      * Limit => ..., default value infinity
      * SourceRing => ..., default value null
      * Strategy => ..., default value null
      * Truncate => ..., default value false
      * Variables => ..., default value null
  * Outputs:
      * a matrix (Macaulay2Doc), the standard monomials of an
        elimination template

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

This method returns a basis of standard mononomials for the ideal represented
by an elimination template.

+-----------------------------------+
|i1 : R = QQ[x,y];                  |
+-----------------------------------+
|i2 : I = ideal(x^2-1, y^2-1);      |
|                                   |
|o2 : Ideal of R                    |
+-----------------------------------+
|i3 : E = eliminationTemplate(x, I);|
+-----------------------------------+
|i4 : getTemplate E;                |
+-----------------------------------+
|i5 : basis E                       |
|                                   |
|o5 = | 1 x xy y |                  |
|                                   |
|             1      4              |
|o5 : Matrix R  <-- R               |
+-----------------------------------+

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

  * basis(EliminationTemplate) -- access
    the quotient basis of an EliminationTemplate
-------------------------------------------------------------------------------

The source of this document is in EliminationTemplates.m2:1112:0.

copyTemplate -- copies EliminationTemplate object
*************************************************

  * Usage:
        F = copyTemplate(E, J)
  * Inputs:
      * E, an instance of the type EliminationTemplate,
        the elimination template to copy
      * J, an ideal (Macaulay2Doc), a zero-dimensional ideal
  * Outputs:
      * F, an instance of the type EliminationTemplate,
        an EliminationTemplate object

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

This method copies an elimination template object, using the same action
variable and basis, but a different defining ideal. The new ideal is expected
to share the Groebner-basis structure of the original (same leading monomials,
same |B|) — this is the specialization regime of copyTemplate.
Note (possible typo in an earlier draft of this docstring): the
example below originally paired I = ideal(x^4+x*y+y^2-3, x^2*y+y^3-2) with J =
ideal(x^3+y^2-1, x^2+y^3-1), which violates this requirement — deg(R/I) = 12
but deg(R/J) = 9, so no single template can serve both. The example below uses
a structurally-compatible replacement J.

+----------------------------------------------+
|i1 : R = QQ[x,y]                              |
|                                              |
|o1 = R                                        |
|                                              |
|o1 : PolynomialRing                           |
+----------------------------------------------+
|i2 : I = ideal(x^4+x*y+y^2-3, x^2*y+y^3-2)    |
|                                              |
|             4          2       2     3       |
|o2 = ideal (x  + x*y + y  - 3, x y + y  - 2)  |
|                                              |
|o2 : Ideal of R                               |
+----------------------------------------------+
|i3 : J = ideal(x^4+2*x*y+y^2-1, 3*x^2*y+y^3-5)|
|                                              |
|             4           2        2     3     |
|o3 = ideal (x  + 2x*y + y  - 1, 3x y + y  - 5)|
|                                              |
|o3 : Ideal of R                               |
+----------------------------------------------+
|i4 : E = eliminationTemplate(x,I)             |
|                                              |
|o4 =  action variable: x                      |
|                                              |
|o4 : EliminationTemplate                      |
+----------------------------------------------+
|i5 : F = copyTemplate(E, J)                   |
|                                              |
|o5 =  action variable: x                      |
|                                              |
|o5 : EliminationTemplate                      |
+----------------------------------------------+

See also
========

  * eliminationTemplate -- constructor for an
    EliminationTemplate object

Ways to use copyTemplate:
=========================

  * "copyTemplate(EliminationTemplate,Ideal)"

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

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

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

The source of this document is in EliminationTemplates.m2:987:0.

EliminationTemplate -- type for elimination template objects
************************************************************

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

The type `EliminationTemplate` represents objects that store the data required
for elimination template computations. An `EliminationTemplate` object encodes
the action variable, the ideal, and a cache for storing computed template data
such as shifts, monomial partitions, and template matrices. These objects are
constructed using the function `eliminationTemplate` and are used as input to
other functions in this package, such as `getTemplateMatrix`,
`getActionMatrix`, and `templateSolve`.

+-------------------------------------------+
|i1 : R = QQ[x,y]                           |
|                                           |
|o1 = R                                     |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : J = ideal(x^2+y^2-1, x^2+x*y+y^2-1)   |
|                                           |
|             2    2       2          2     |
|o2 = ideal (x  + y  - 1, x  + x*y + y  - 1)|
|                                           |
|o2 : Ideal of R                            |
+-------------------------------------------+
|i3 : E = eliminationTemplate(x, J)         |
|                                           |
|o3 =  action variable: x                   |
|                                           |
|o3 : EliminationTemplate                   |
+-------------------------------------------+
|i4 : E                                     |
|                                           |
|o4 =  action variable: x                   |
|                                           |
|o4 : EliminationTemplate                   |
+-------------------------------------------+

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

  * "actionVariable(EliminationTemplate)" -- see actionVariable,
    -- returns the action variable associated to the
    elimination template
  * basis(EliminationTemplate) -- access
    the quotient basis of an EliminationTemplate
  * "copyTemplate(EliminationTemplate,Ideal)" -- see copyTemplate,
    -- copies EliminationTemplate object
  * "getActionMatrix(EliminationTemplate)" -- see getActionMatrix,
    -- computes or retrieves a template's action matrix
  * "getTemplate(EliminationTemplate)" -- see getTemplate,
    -- construct the shifts and monomial partition for an elimination template
  * "getTemplateMatrix(EliminationTemplate)" -- see getTemplateMatrix,
    -- computes template matrix
  * ideal(EliminationTemplate) -- access
    the ideal of an EliminationTemplate
  * net(EliminationTemplate) -- display an
    EliminationTemplate
  * "templateSolve(EliminationTemplate)" -- see templateSolve,
    -- polynomial system solver using elimination templates

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

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

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

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

eliminationTemplate -- constructor for an EliminationTemplate object
********************************************************************

  * Usage:
        E = eliminationTemplate(a, J)
  * Inputs:
      * a, a ring element (Macaulay2Doc), the action
        polynomial defining a multiplication matrix
      * J, an ideal (Macaulay2Doc), a zero-dimensional ideal
  * Outputs:
      * E, an instance of the type EliminationTemplate,
        an EliminationTemplate object encoding the data
        for elimination template computations

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

This function constructs an EliminationTemplate object, which stores the action
variable and ideal, and provides a cache for storing computed template data.
The EliminationTemplate object can be used with other functions in this package
to compute template matrices, action matrices, and solve polynomial systems.

+-------------------------------------------+
|i1 : R = QQ[x,y]                           |
|                                           |
|o1 = R                                     |
|                                           |
|o1 : PolynomialRing                        |
+-------------------------------------------+
|i2 : J = ideal(x^2+y^2-1, x^2+x*y+y^2-1)   |
|                                           |
|             2    2       2          2     |
|o2 = ideal (x  + y  - 1, x  + x*y + y  - 1)|
|                                           |
|o2 : Ideal of R                            |
+-------------------------------------------+
|i3 : E = eliminationTemplate(x, J)         |
|                                           |
|o3 =  action variable: x                   |
|                                           |
|o3 : EliminationTemplate                   |
+-------------------------------------------+

Ways to use eliminationTemplate:
================================

  * "eliminationTemplate(RingElement,Ideal)"

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

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

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

The source of this document is in EliminationTemplates.m2:898:0.

getActionMatrix -- computes or retrieves a template's action matrix
*******************************************************************

  * Usage:
        A = getActionMatrix E
  * Inputs:
      * E, an instance of the type EliminationTemplate,
        an elimination template
  * Optional inputs (Macaulay2Doc),:
      * AdjustParams (missing documentation) => ..., default value true,
      * MonomialOrder (missing documentation) => ..., default value null,
      * Strategy (missing documentation) => ..., default value null,
  * Outputs:
      * A, a matrix (Macaulay2Doc), the action matrix

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

For a zero-dimensional polynomial ideal $I \subset R$, multiplication by a
general linear form $f \in R$ induces a linear map $R/I \to R/I$, which can be
represented using an action matrix. For an ideal represented by a template
matrix, the action matrix may be obtained from the template matrix by various
triangularization schemes (RREF, LU Decomposition, etc.) The eigenvalues can be
used to determine the (closed) points in the vanishing locus of $I$, as they
give the values of $f$ on these points. In this implementation, the action
matrix is cached inside the template to facilitate quicker computation.

+----------------------------------------+
|i1 : R = QQ[x,y]                        |
|                                        |
|o1 = R                                  |
|                                        |
|o1 : PolynomialRing                     |
+----------------------------------------+
|i2 : I = ideal(x + y - 1, x^2 + y^2 - 1)|
|                                        |
|                        2    2          |
|o2 = ideal (x + y - 1, x  + y  - 1)     |
|                                        |
|o2 : Ideal of R                         |
+----------------------------------------+
|i3 : E = eliminationTemplate(x,I)       |
|                                        |
|o3 =  action variable: x                |
|                                        |
|o3 : EliminationTemplate                |
+----------------------------------------+
|i4 : A = getActionMatrix E              |
|                                        |
|o4 = | 0  0 |                           |
|     | -1 1 |                           |
|                                        |
|              2       2                 |
|o4 : Matrix QQ  <-- QQ                  |
+----------------------------------------+
|i5 : eigenvalues A                      |
|                                        |
|o5 = {1}                                |
|     {0}                                |
|                                        |
|o5 : VerticalList                       |
+----------------------------------------+

See also
========

  * EliminationTemplate -- type for elimination
    template objects
  * getTemplateMatrix -- computes template matrix

Ways to use getActionMatrix:
============================

  * "getActionMatrix(EliminationTemplate)"

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

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

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

The source of this document is in EliminationTemplates.m2:1019:0.

getTemplate -- construct the shifts and monomial partition for an elimination template
**************************************************************************************

  * Usage:
        (sh, mp) = getTemplate E
  * Inputs:
      * E, an instance of the type EliminationTemplate,
  * Optional inputs (Macaulay2Doc),:
      * Strategy => a string (Macaulay2Doc), default value null,
        the algorithm used to compute the template: "Greedy" (default),
        "Larsson", or null (standard GB)
      * AdjustParams => a Boolean value (Macaulay2Doc), default
        value true, whether to run the greedy parameter-commit step (α-commit)
        for Martyushev's strategy
      * MonomialOrder => a symbol (Macaulay2Doc), default value
        null, override the default monomial order of the ring
  * Outputs:
      * sh, an instance of the type ShiftSet (missing documentation), a list of
        shift monomials applied to the generators of the ideal
      * mp, an instance of the type MonomialPartition (missing documentation),
        a list of three sets of monomials: {excess, residual, basis}

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

This method is the core of the EliminationTemplates, pipeline. It
identifies the necessary polynomial shifts and partitions the resulting
monomial support into three blocks:

*   Excess: Monomials eliminated during the construction. *   Residual:
Monomials of the form $a \cdot b_i$ that are not in the basis. *   Basis: The
monomials spanning the quotient ring $R/I$.

If the action variable is a polynomial rather than a single variable, the
method automatically performs a lift to the graph ring $R[s] / \langle s - a
\rangle$.

+-----------------------------------------------------+
|i1 : R = QQ[x,y];                                    |
+-----------------------------------------------------+
|i2 : I = ideal(x^2-y, y^2-x);                        |
|                                                     |
|o2 : Ideal of R                                      |
+-----------------------------------------------------+
|i3 : E = eliminationTemplate(x, I);                  |
+-----------------------------------------------------+
|i4 : (sh, mp) = getTemplate(E, Strategy => "Greedy");|
+-----------------------------------------------------+
|i5 : mp                                              |
|                                                     |
|        2     2    2                                 |
|o5 = {{y }, {x y, x }, {x*y, x, y, 1}}               |
|                                                     |
|o5 : MonomialPartition                               |
+-----------------------------------------------------+

See also
========

  * getTemplateMatrix -- computes template matrix
  * getActionMatrix -- computes or retrieves a
    template's action matrix

Ways to use getTemplate:
========================

  * "getTemplate(EliminationTemplate)"

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

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

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

The source of this document is in EliminationTemplates.m2:871:0.

getTemplateMatrix -- computes template matrix
*********************************************

  * Usage:
        M = getTemplateMatrix(a, B, J)
        M = getTemplateMatrix(sh, mp, J)
        getTemplateMatrix(E)
  * Inputs:
      * a, a ring element (Macaulay2Doc), the action
        polynomial defining a multiplication matrix
      * B, a matrix (Macaulay2Doc),
      * E, an instance of the type EliminationTemplate,
        the elimination template for this problem
      * J, an ideal (Macaulay2Doc),
      * mp, an instance of the type MonomialPartition (missing documentation),
      * sh, an instance of the type ShiftSet (missing documentation),
  * Optional inputs (Macaulay2Doc),:
      * MonomialOrder (missing documentation) => a thing (Macaulay2Doc),
        default value null, the monomial order used on
        the ambient ring
      * Strategy (missing documentation) => a thing (Macaulay2Doc),
        default value null, the strategy used to compute
        H0
      * AdjustParams (missing documentation) => ..., default value true,
  * Outputs:
      * M, a matrix (Macaulay2Doc),

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

This method computes the template matrix corresponding to the inputted
elimination template.

+---------------------------------------------------+
|i1 : R = QQ[x,y]                                   |
|                                                   |
|o1 = R                                             |
|                                                   |
|o1 : PolynomialRing                                |
+---------------------------------------------------+
|i2 : I = ideal(x^4+x*y+y^2-3, x^2*y+y^3-2)         |
|                                                   |
|             4          2       2     3            |
|o2 = ideal (x  + x*y + y  - 3, x y + y  - 2)       |
|                                                   |
|o2 : Ideal of R                                    |
+---------------------------------------------------+
|i3 : E = eliminationTemplate(x,I)                  |
|                                                   |
|o3 =  action variable: x                           |
|                                                   |
|o3 : EliminationTemplate                           |
+---------------------------------------------------+
|i4 : getTemplateMatrix(E)                          |
|                                                   |
|o4 = | 1 0 0 0 0 0 0  0 1 1 0 0 0 0  0 -3 0 0  0  ||
|     | 0 1 0 0 0 0 0  0 0 0 0 1 1 0  0 0  0 -3 0  ||
|     | 0 0 0 0 1 0 0  0 0 0 0 0 0 0  1 1  0 0  -3 ||
|     | 1 0 1 0 0 0 -2 0 0 0 0 0 0 0  0 0  0 0  0  ||
|     | 0 1 0 1 0 0 0  0 0 0 0 0 0 -2 0 0  0 0  0  ||
|     | 0 0 0 0 0 1 0  0 0 1 0 0 0 0  0 0  0 -2 0  ||
|     | 0 0 0 0 0 0 1  0 0 0 0 0 1 0  0 0  0 0  -2 ||
|                                                   |
|              7       19                           |
|o4 : Matrix QQ  <-- QQ                             |
+---------------------------------------------------+

See also
========

  * EliminationTemplate -- type for elimination
    template objects

Ways to use getTemplateMatrix:
==============================

  * "getTemplateMatrix(EliminationTemplate)"
  * "getTemplateMatrix(RingElement,Matrix,Ideal)"

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

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

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

The source of this document is in EliminationTemplates.m2:1060:0.

ideal(EliminationTemplate) -- access the ideal of an EliminationTemplate
************************************************************************

  * Function: ideal (Macaulay2Doc),
  * Usage:
        ideal E
  * Inputs:
      * E, an instance of the type EliminationTemplate,
  * Outputs:
      * an ideal (Macaulay2Doc), the ideal J from which the
        template was constructed

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

This method retrieves the original ideal J associated with the
EliminationTemplate.

+-----------------------------------+
|i1 : R = QQ[x,y];                  |
+-----------------------------------+
|i2 : I = ideal(x^2-1, y^2-1);      |
|                                   |
|o2 : Ideal of R                    |
+-----------------------------------+
|i3 : E = eliminationTemplate(x, I);|
+-----------------------------------+
|i4 : ideal E === I                 |
|                                   |
|o4 = true                          |
+-----------------------------------+

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

  * ideal(EliminationTemplate) -- access
    the ideal of an EliminationTemplate
-------------------------------------------------------------------------------

The source of this document is in EliminationTemplates.m2:1083:0.

net(EliminationTemplate) -- display an EliminationTemplate
**********************************************************

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

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

This method formats an EliminationTemplate, for
printing. It lists the action variable and, if they have been computed and
cached, the template matrix and the action matrix.

+-----------------------------------+
|i1 : R = QQ[x,y];                  |
+-----------------------------------+
|i2 : I = ideal(x^2-1, y^2-1);      |
|                                   |
|o2 : Ideal of R                    |
+-----------------------------------+
|i3 : E = eliminationTemplate(x, I);|
+-----------------------------------+
|i4 : net E                         |
|                                   |
|o4 =  action variable: x           |
+-----------------------------------+

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

  * net(EliminationTemplate) -- display an
    EliminationTemplate
-------------------------------------------------------------------------------

The source of this document is in EliminationTemplates.m2:1135:0.

templateSolve -- polynomial system solver using elimination templates
*********************************************************************

  * Usage:
        sols = templateSolve(et)
        sols = templateSolve(J)
        sols = templateSolve(a, J)
  * Inputs:
      * a, a ring element (Macaulay2Doc), the action
        polynomial defining a multiplication matrix
      * J, an ideal (Macaulay2Doc), a zero-dimensional ideal
      * et, an instance of the type EliminationTemplate,
        the elimination template for this problem
  * Optional inputs (Macaulay2Doc),:
      * MonomialOrder (missing documentation) => a thing (Macaulay2Doc),
        default value null, the monomial order used on
        the ambient ring
      * Strategy (missing documentation) => a thing (Macaulay2Doc),
        default value null, null (default), "Larsson", or
        "Greedy"
      * AdjustParams (missing documentation) => a Boolean value (Macaulay2Doc),
        default value true, true (default) runs the
        full Greedy commit; false stops at the particular solution α := 0
        ("MatrixHi mode")
  * Outputs:
      * sols, a list (Macaulay2Doc), a list of solutions; each
        solution is itself a list of complex numbers, one per ring variable of
        the ambient ring, in declaration order

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

In the example below, the ideal $J$ defines a zero-dimensional variety with
four points. This method finds numerical approximations to these four points by
solving an eigenvalue problem, much like the package EigenSolver.
The main advantage of elimination templates is that the
internal template matrix may be reused for problems of a "similar structure"
(see copyTemplate).

+------------------------------------------------------------+
|i1 : R = QQ[x,y]                                            |
|                                                            |
|o1 = R                                                      |
|                                                            |
|o1 : PolynomialRing                                         |
+------------------------------------------------------------+
|i2 : J = ideal(x^2+y^2-1,x^2+x*y+y^2-1)                     |
|                                                            |
|             2    2       2          2                      |
|o2 = ideal (x  + y  - 1, x  + x*y + y  - 1)                 |
|                                                            |
|o2 : Ideal of R                                             |
+------------------------------------------------------------+
|i3 : actVar = x + 2*y                                       |
|                                                            |
|o3 = x + 2y                                                 |
|                                                            |
|o3 : R                                                      |
+------------------------------------------------------------+
|i4 : templateSolve(actVar, J)                               |
|                                                            |
|o4 = {{1, 0}, {-1, 0}, {7.85046e-17, 1}, {-4.57558e-16, -1}}|
|                                                            |
|o4 : List                                                   |
+------------------------------------------------------------+

Ways to use templateSolve:
==========================

  * "templateSolve(EliminationTemplate)"
  * "templateSolve(Ideal)"
  * "templateSolve(RingElement,Ideal)"

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

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

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

The source of this document is in EliminationTemplates.m2:947:0.