This is SagbiGbDetection.info, produced by Macaulay2, version 1.25.05

SagbiGbDetection -- A package for finding term orders for which the given generators of an ideal/algebra form a Gröbner/SAGBI basis (resp.)
*******************************************************************************************************************************************

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

The main functions of this package implement the detection algorithms for
Gröbner bases of ideals and SAGBI bases of finitely generated subalgebras of a
polynomial ring. More precisely, for given generators of an ideal or a
polynomial algebra, we find weight vectors representing all possible term
orders for which these generators form a Gröbner basis or a SAGBI basis,
respectively. If no weight vectors are returned, the given generators do not
form a Gröbner/SAGBI basis for any order.

Documentation nodes for the main functions weightVectorsRealizingGB,
and weightVectorsRealizingSAGBI,
illustrate typical usage of this package.

References
==========

  * Gritzmann, Peter, and Bernd Sturmfels. Minkowski addition of polytopes:
    computational complexity and applications to Gröbner bases. SIAM Journal on
    Discrete Mathematics 6.2 (1993): 246-269.
  * Sturmfels, Bernd. Grobner bases and convex polytopes. Vol. 8. American
    Mathematical Soc., 1996.

Authors
=======

  * Viktoriia Borovik (see https://sites.google.com/view/viktoriia-borovik/home
    ) <vborovik@uni-osnabrueck.de>
  * Timothy Duff (see https://timduff35.github.io/timduff35/ ) <timduff@uw.edu>
  * Elima Shehu (see https://sites.google.com/view/elimawebsite/home )
    <shehu@mis.mpg.de>

Version
=======

This documentation describes version 0.1 of SagbiGbDetection.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{SagbiGbDetectionSource,                                               |
|  title = {{SagbiGbDetection: A \emph{Macaulay2} package. Version~0.1}},    |
|  author = {Viktoriia Borovik and Timothy Duff and Elima Shehu},            |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * weightVectorsRealizingGB -- The main
        function for detecting Gröbner bases
      * weightVectorsRealizingSAGBI -- The
        main function for detecting SAGBI bases
  * Methods
      * "weightVectorsRealizingGB(List)" -- see weightVectorsRealizingGB,
        -- The main function for detecting Gröbner
        bases
      * "weightVectorsRealizingGB(Matrix)" -- see
        weightVectorsRealizingGB, -- The main
        function for detecting Gröbner bases
      * "weightVectorsRealizingSAGBI(List)" -- see
        weightVectorsRealizingSAGBI, -- The main
        function for detecting SAGBI bases
      * "weightVectorsRealizingSAGBI(Matrix)" -- see
        weightVectorsRealizingSAGBI, -- The main
        function for detecting SAGBI bases

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

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

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

The source of this document is in SagbiGbDetection.m2:139:0.

weightVectorsRealizingSAGBI -- The main function for detecting SAGBI bases
**************************************************************************

  * Usage:
        S = weightVectorsRealizingSAGBI Q
  * Inputs:
      * Q, a list (Macaulay2Doc), of polynomials in the same ring
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => ..., default value false,
  * Outputs:
      * S, a list (Macaulay2Doc), (possibly empty) containing
        weight vectors for which Q forms a SAGBI basis

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

Here are two examples where we find one or more weight vectors for which the
polynomials form a SAGBI basis.

+-----------------------------------------------------+
|i1 : S1 = QQ[x,y,z, MonomialOrder=>Lex];             |
+-----------------------------------------------------+
|i2 : Q1 = {z, z*x, z*y, z*x*(x^2+y^2),z*y*(x^2+y^2)};|
+-----------------------------------------------------+
|i3 : weightVectorsRealizingSAGBI Q1                  |
|                                                     |
|o3 = {{2, 1, 1}, {1, 2, 1}}                          |
|                                                     |
|o3 : List                                            |
+-----------------------------------------------------+
|i4 : S2 = QQ[x, MonomialOrder=>Lex];                 |
+-----------------------------------------------------+
|i5 : Q2 = {x^4+x^3, x^2+x, x^3 + x^2};               |
+-----------------------------------------------------+
|i6 : weightVectorsRealizingSAGBI Q2                  |
|                                                     |
|o6 = {{1}}                                           |
|                                                     |
|o6 : List                                            |
+-----------------------------------------------------+

Here is an example where the algebra generators are not a SAGBI basis for any
term order.

+--------------------------------------+
|i7 : S3 = QQ[x,y, MonomialOrder=>Lex];|
+--------------------------------------+
|i8 : Q3 = {x+y, x*y, x*y^2};          |
+--------------------------------------+
|i9 : weightVectorsRealizingSAGBI Q3   |
|                                      |
|o9 = {}                               |
|                                      |
|o9 : List                             |
+--------------------------------------+

Ways to use weightVectorsRealizingSAGBI:
========================================

  * "weightVectorsRealizingSAGBI(List)"
  * "weightVectorsRealizingSAGBI(Matrix)"

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

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

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

The source of this document is in SagbiGbDetection.m2:215:0.

weightVectorsRealizingGB -- The main function for detecting Gröbner bases
*************************************************************************

  * Usage:
        S = weightVectorsRealizingGB G
  * Inputs:
      * G, a list (Macaulay2Doc), of polynomials in the same ring
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => ..., default value false,
  * Outputs:
      * S, a list (Macaulay2Doc), (possibly empty) containing
        weight vectors for which Q forms a Gröbner basis

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

We give three examples of ideal generators that are Gröbner bases for the
indicated term orders below:

+-----------------------------------------------------------------------------+
|i1 : R1 = QQ[x,y, MonomialOrder=>Lex];                                       |
+-----------------------------------------------------------------------------+
|i2 : G1 = {y^2-x, x^2-1};                                                    |
+-----------------------------------------------------------------------------+
|i3 : weightVectorsRealizingGB G1                                             |
|                                                                             |
|o3 = {{2, 2}}                                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : R2 = QQ[x,y,z, MonomialOrder=>Lex]                                      |
|                                                                             |
|o4 = R2                                                                      |
|                                                                             |
|o4 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i5 : G2 = {x^3-y, x^5-z}                                                     |
|                                                                             |
|       3       5                                                             |
|o5 = {x  - y, x  - z}                                                        |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : weightVectorsRealizingGB G2                                             |
|                                                                             |
|o6 = {{2, 7, 5}, {2, 3, 11}, {1, 4, 6}}                                      |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : R3 = QQ[x,y,z,w, MonomialOrder=>Lex]                                    |
|                                                                             |
|o7 = R3                                                                      |
|                                                                             |
|o7 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i8 : G3 = {x^2-z, x*y-z^2, x*z-y, w-z^2, y^2-z^3}                            |
|                                                                             |
|       2             2              2       2    3                           |
|o8 = {x  - z, x*y - z , x*z - y, - z  + w, y  - z }                          |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : weightVectorsRealizingGB G3                                             |
|                                                                             |
|o9 = {{3, 8, 4, 4}, {2, 5, 2, 5}, {3, 4, 2, 5}, {1, 6, 3, 7}, {1, 8, 5, 11}, |
|     ------------------------------------------------------------------------|
|     {4, 3, 3, 7}, {4, 3, 5, 11}, {1, 7, 5, 11}}                             |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+

Here are two examples of generating sets which are not Gröbner bases:

+-------------------------------------------+
|i10 : R4 = QQ[x,y, MonomialOrder=>Lex];    |
+-------------------------------------------+
|i11 : G4 = {x^2+y^2-1, 2*x*y-1};           |
+-------------------------------------------+
|i12 : weightVectorsRealizingGB G4          |
|                                           |
|o12 = {}                                   |
|                                           |
|o12 : List                                 |
+-------------------------------------------+
|i13 : R5 = QQ[x,y,z, MonomialOrder=>Lex];  |
+-------------------------------------------+
|i14 : G5 = {x*y^2-x*z+y, x*y-z^2, x-y*z^4};|
+-------------------------------------------+
|i15 : weightVectorsRealizingGB G5          |
|                                           |
|o15 = {}                                   |
|                                           |
|o15 : List                                 |
+-------------------------------------------+

Ways to use weightVectorsRealizingGB:
=====================================

  * "weightVectorsRealizingGB(List)"
  * "weightVectorsRealizingGB(Matrix)"

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

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

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

The source of this document is in SagbiGbDetection.m2:181:0.