This is EigenSolver.info, produced by Macaulay2, version 1.21

EigenSolver -- polynomial system solver via eigen-computations
**************************************************************

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

This package implements a solver for zero-dimensional polynomial systems based
on eigenvalue/eigenvector computations. The theoretical basis for this is
Stickelberger's Theorem (cf. [1, Theorem 2.6], also [2]), which states that if
I is a zero-dimensional ideal in a polynomial ring $R$ over an algebraically
closed field $k$, then the points of V(I) can be obtained as eigenvalues of
multiplication matrices corresponding to variables, on the finite-dimensional
$k$-vector space $R/I$.

Since the main solving is done via linear algebra, this solver can be
significantly quicker than other solvers performing nonlinear computations.
However, a Grobner basis of the ideal I is still needed, e.g. in order to
obtain the sizes of the multiplication matrices.

+-----------------------------------------------------------------------------+
|i1 : needsPackage "ExampleSystems"                                           |
|                                                                             |
|o1 = ExampleSystems                                                          |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : I = ideal cyclic(6, QQ)                                                 |
|                                                                             |
|o2 = ideal (a + b + c + d + e + f, a*b + b*c + c*d + d*e + a*f + e*f, a*b*c +|
|     ------------------------------------------------------------------------|
|     b*c*d + c*d*e + a*b*f + a*e*f + d*e*f, a*b*c*d + b*c*d*e + a*b*c*f +    |
|     ------------------------------------------------------------------------|
|     a*b*e*f + a*d*e*f + c*d*e*f, a*b*c*d*e + a*b*c*d*f + a*b*c*e*f +        |
|     ------------------------------------------------------------------------|
|     a*b*d*e*f + a*c*d*e*f + b*c*d*e*f, a*b*c*d*e*f - 1)                     |
|                                                                             |
|o2 : Ideal of QQ[a..f]                                                       |
+-----------------------------------------------------------------------------+
|i3 : elapsedTime sols = zeroDimSolve I;                                      |
| -- 1.01319 seconds elapsed                                                  |
+-----------------------------------------------------------------------------+
|i4 : #sols -- 156 solutions                                                  |
|                                                                             |
|o4 = 156                                                                     |
+-----------------------------------------------------------------------------+

The authors would like to acknowledge the June 2020 Macaulay2 workshop held
virtually at Warwick, where this package was first developed.

References:

  * [1] Sturmfels, Bernd. Solving systems of polynomial equations. No. 97.
    American Mathematical Soc., 2002
  * [2] Cox, David A. Stickelberger and the Eigenvalue Theorem.
    https://arxiv.org/abs/2007.12573

Authors
=======

  * Laurent Busé <Laurent.Buse@inria.fr>
  * Justin Chen <justin.chen@math.gatech.edu>
  * Kisun Lee <kil004@ucsd.edu>
  * Anton Leykin <anton.leykin@gmail.com>
  * Tomas Pajdla <pajdla@cvut.cz>
  * Erika Pirnes <pirnes@wisc.edu>

Version
=======

This documentation describes version 0.1 of EigenSolver.

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

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

Exports
=======

  * Functions and commands
      * zeroDimSolve -- zero-dimensional polynomial system
        solver
  * Methods
      * "zeroDimSolve(Ideal)" -- see zeroDimSolve, --
        zero-dimensional polynomial system solver
  * Symbols
      * "Basis" -- see zeroDimSolve, -- zero-dimensional
        polynomial system solver
      * "Multiplier" -- see zeroDimSolve, --
        zero-dimensional polynomial system solver

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

The object EigenSolver, is a package (Macaulay2Doc).

zeroDimSolve -- zero-dimensional polynomial system solver
*********************************************************

Synopsis
========

  * Usage:
        zeroDimSolve(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc), a zero-dimensional ideal
  * Optional inputs (Macaulay2Doc),:
      * Basis (missing documentation) => ..., default value null, null
      * Multiplier (missing documentation) => ..., default value 0, null
      * Strategy (missing documentation) => ..., default value "Stickelberger",
        null
      * Tolerance (missing documentation) => ..., default value .000001, null
  * Outputs:
      * a list (Macaulay2Doc), of points on V(I)

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

This function is a general-purpose solver for zero-dimensional polynomial
systems. The default Strategy is "Stickelberger", which leverages
Stickelberger's theorem to compute the coordinates of solution points as
(joint) eigenvalues of multiplication matrices corresponding to the variables
of the ring.

The option Multiplier allows the user to specify the linear form used to
construct the multiplication matrix. For example, if the ambient polynomial
ring is $QQ[x,y,z]$ and only the $y$-coordinates of solutions are needed, then
one can specify Multiplier => y (and ignore the coordinates of other solution
points). By default, a random linear form is used: due to this, it may be
helpful to run this function a couple of times to minimize the likelihood of a
"bad" linear form being chosen.

The option Basis allows the user to specify a basis of the quotient $R/I$, if
one is known. The default value is null, in which case a basis for $R/I$ will
be computed via a Grobner basis computation.

In general, Strategy => "Stickelberger" does not require the input ideal I to
be radical, so solutions may appear with multiplicity:

+-------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                         |
|                                                                         |
|o1 = R                                                                   |
|                                                                         |
|o1 : PolynomialRing                                                      |
+-------------------------------------------------------------------------+
|i2 : I = ideal"x2,xy,y3"                                                 |
|                                                                         |
|             2        3                                                  |
|o2 = ideal (x , x*y, y )                                                 |
|                                                                         |
|o2 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i3 : sols = zeroDimSolve I                                               |
|                                                                         |
|o3 = {{0, 0}, {-8.90741e-293, 0}, {0, -8.01667e-292}, {0, -8.01667e-292}}|
|                                                                         |
|o3 : List                                                                |
+-------------------------------------------------------------------------+
|i4 : #sols == 4 and all(sols, p -> clean(1e-16, matrix p) == 0)          |
|                                                                         |
|o4 = true                                                                |
+-------------------------------------------------------------------------+

See also
========

  * solveSystem (missing documentation)

Ways to use zeroDimSolve :
==========================

  * "zeroDimSolve(Ideal)"

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

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