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

SlackIdeals -- a package for slack ideals of polytopes and matroids
*******************************************************************

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

SlackIdeals is a package which allows the user to create slack realizations and
the slack ideal of a polytope or a matroid. Polytopes and matroids may be
entered as a list of vertices of a specific realization or as a pre-created
Polyhedron or Matroid object (using the packages Polyhedra,
and Matroids).

References.

  * [GMTW19] The slack realization space of a polytope, (J. Gouveia, A.
    Macchia, R.R. Thomas, A. Wiebe, SIAM J. Discrete Math. 33 (2019), 3,
    1637–1653.)
  * [BW19] The slack realization space of a matroid, (M. Brandt, A. Wiebe,
    Algebraic Combinatorics, 2 (2019), 4, 663–681, 2019.)
  * [BMTW20] Projectively unique polytopes and toric slack ideals, (J. Gouveia,
    A. Macchia, R.R. Thomas, A. Wiebe, J. Pure Appl. Algebra 224 (2020), 5,
    paper 106229.)
  * [BMW20] Combining realization space models of polytopes, (J. Gouveia, A.
    Macchia, A. Wiebe, preprint (2020), arXiv:2001.11999v1.)

Authors
=======

  * Amy Wiebe <w.amy.math@gmail.com>
  * Antonio Macchia <macchia.antonello@gmail.com>

Version
=======

This documentation describes version 1.0 of SlackIdeals.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{SlackIdealsSource,                                                     |
|  title = {{SlackIdeals: Slack ideals of polytopes and matroids. Version~1.0 |
|  author = {Amy Wiebe and Antonio Macchia},                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|}},                                                                          |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * containsFlag -- establishes whether or not a list
        of facet labels contains a flag in a polytope or matroid
      * cycleIdeal -- constructs the cycle ideal of a
        realization
      * findFlag -- computes a list of facet labels that make
        up a flag in a polytope
      * getFacetBases -- get a list of d-spanning
        elements for each facet
      * graphFromSlackMatrix -- creates the
        vertex-edge incidence matrix for the bipartite non-incidence graph with
        adjacency matrix the given slack matrix
      * graphicIdeal -- creates the toric ideal of the
        non-incidence graph of a polytope
      * grassmannSectionIdeal -- compute the
        Grassmannian section ideal corresponding to a slack matrix
      * reconstructSlackMatrix -- a list of
        facet labels that make up a flag in a polytope
      * reducedSlackMatrix -- a reduced slack matrix
        of a polytope
      * rehomogenizeIdeal -- rehomogenization of a
        the dehomogenized slack ideal
      * rehomogenizePolynomial, --
        rehomogenization of a polynomial reversing the dehomogenization of the
        slack matrix
      * setOnesForest -- sets to 1 variables in a
        symbolic slack matrix which corresponding to edges of a spanning forest
      * slackFromGaleCircuits -- computes the
        slack matrix of a polytope from a Gale transform of the polytope
      * slackFromGalePlucker -- fill the slack
        matrix with Plücker coordinates of the Gale transform
      * slackFromPlucker -- fill the slack matrix of a
        given polytope, cone or matroid with Plücker coordinates
      * slackIdeal -- computes the slack ideal
      * slackMatrix -- computes the slack matrix of a given
        realization
      * specificSlackMatrix -- creates built-in
        slack matrices of some polytopes and matroids
      * symbolicSlackMatrix -- computes the
        symbolic slack matrix
      * symbolicSlackOfPlucker -- fill the slack
        matrix with Plücker variables
      * toricPolytope -- computes the polytope whose
        toric ideal is the given ideal
      * universalIdeal -- computes the universal
        realization ideal of a matroid
  * Methods
      * "containsFlag(List,List)" -- see containsFlag, --
        establishes whether or not a list of facet labels contains a flag in a
        polytope or matroid
      * "containsFlag(List,Matrix)" -- see containsFlag, --
        establishes whether or not a list of facet labels contains a flag in a
        polytope or matroid
      * "containsFlag(List,Matroid)" -- see containsFlag,
        -- establishes whether or not a list of facet labels contains a flag in
        a polytope or matroid
      * "containsFlag(List,Polyhedron)" -- see containsFlag,
        -- establishes whether or not a list of facet labels
        contains a flag in a polytope or matroid
      * "cycleIdeal(List)" -- see cycleIdeal, -- constructs
        the cycle ideal of a realization
      * "cycleIdeal(Matrix)" -- see cycleIdeal, -- constructs
        the cycle ideal of a realization
      * "cycleIdeal(Matroid)" -- see cycleIdeal, --
        constructs the cycle ideal of a realization
      * "cycleIdeal(Polyhedron)" -- see cycleIdeal, --
        constructs the cycle ideal of a realization
      * "findFlag(List)" -- see findFlag, -- computes a list of
        facet labels that make up a flag in a polytope
      * "findFlag(Matrix)" -- see findFlag, -- computes a list
        of facet labels that make up a flag in a polytope
      * "findFlag(Matroid)" -- see findFlag, -- computes a list
        of facet labels that make up a flag in a polytope
      * "findFlag(Polyhedron)" -- see findFlag, -- computes a
        list of facet labels that make up a flag in a polytope
      * "getFacetBases(List)" -- see getFacetBases, -- get
        a list of d-spanning elements for each facet
      * "getFacetBases(Matrix)" -- see getFacetBases, --
        get a list of d-spanning elements for each facet
      * "getFacetBases(Matroid)" -- see getFacetBases, --
        get a list of d-spanning elements for each facet
      * "getFacetBases(Polyhedron)" -- see getFacetBases,
        -- get a list of d-spanning elements for each facet
      * "graphFromSlackMatrix(Matrix)" -- see graphFromSlackMatrix,
        -- creates the vertex-edge incidence matrix for
        the bipartite non-incidence graph with adjacency matrix the given slack
        matrix
      * "graphicIdeal(List)" -- see graphicIdeal, --
        creates the toric ideal of the non-incidence graph of a polytope
      * "graphicIdeal(Matrix)" -- see graphicIdeal, --
        creates the toric ideal of the non-incidence graph of a polytope
      * "graphicIdeal(Matroid)" -- see graphicIdeal, --
        creates the toric ideal of the non-incidence graph of a polytope
      * "graphicIdeal(Polyhedron)" -- see graphicIdeal, --
        creates the toric ideal of the non-incidence graph of a polytope
      * "grassmannSectionIdeal(Cone)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "grassmannSectionIdeal(List)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "grassmannSectionIdeal(List,List)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "grassmannSectionIdeal(Matrix)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "grassmannSectionIdeal(Matrix,List)" -- see
        grassmannSectionIdeal, -- compute the
        Grassmannian section ideal corresponding to a slack matrix
      * "grassmannSectionIdeal(Matroid)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "grassmannSectionIdeal(Polyhedron)" -- see grassmannSectionIdeal,
        -- compute the Grassmannian section ideal
        corresponding to a slack matrix
      * "reconstructSlackMatrix(Matrix,List)" -- see
        reconstructSlackMatrix, -- a list of facet
        labels that make up a flag in a polytope
      * "reconstructSlackMatrix(Matrix,List,List)" -- see
        reconstructSlackMatrix, -- a list of facet
        labels that make up a flag in a polytope
      * "reducedSlackMatrix(List)" -- see reducedSlackMatrix,
        -- a reduced slack matrix of a polytope
      * "reducedSlackMatrix(Matrix)" -- see reducedSlackMatrix,
        -- a reduced slack matrix of a polytope
      * "reducedSlackMatrix(ZZ,Matrix)" -- see reducedSlackMatrix,
        -- a reduced slack matrix of a polytope
      * "rehomogenizeIdeal(ZZ,Matrix)" -- see rehomogenizeIdeal,
        -- rehomogenization of a the dehomogenized slack
        ideal
      * "rehomogenizeIdeal(ZZ,Matrix,Graph)" -- see rehomogenizeIdeal,
        -- rehomogenization of a the dehomogenized slack
        ideal
      * "rehomogenizePolynomial(Matrix)" -- see rehomogenizePolynomial,
        -- rehomogenization of a polynomial reversing
        the dehomogenization of the slack matrix
      * "rehomogenizePolynomial(Matrix,Matrix,Graph,RingElement)" -- see
        rehomogenizePolynomial, -- rehomogenization of
        a polynomial reversing the dehomogenization of the slack matrix
      * "setOnesForest(Matrix)" -- see setOnesForest, --
        sets to 1 variables in a symbolic slack matrix which corresponding to
        edges of a spanning forest
      * "slackFromGaleCircuits(Matrix)" -- see slackFromGaleCircuits,
        -- computes the slack matrix of a polytope from
        a Gale transform of the polytope
      * "slackFromGalePlucker(List,List)" -- see slackFromGalePlucker,
        -- fill the slack matrix with Plücker coordinates
        of the Gale transform
      * "slackFromGalePlucker(List,Matrix)" -- see slackFromGalePlucker,
        -- fill the slack matrix with Plücker coordinates
        of the Gale transform
      * "slackFromPlucker(List)" -- see slackFromPlucker,
        -- fill the slack matrix of a given polytope, cone or
        matroid with Plücker coordinates
      * "slackFromPlucker(List,List)" -- see slackFromPlucker,
        -- fill the slack matrix of a given polytope, cone or
        matroid with Plücker coordinates
      * "slackFromPlucker(Matroid)" -- see slackFromPlucker,
        -- fill the slack matrix of a given polytope, cone or
        matroid with Plücker coordinates
      * "slackFromPlucker(Polyhedron)" -- see slackFromPlucker,
        -- fill the slack matrix of a given polytope, cone or
        matroid with Plücker coordinates
      * "slackIdeal(Cone)" -- see slackIdeal, -- computes the
        slack ideal
      * "slackIdeal(List)" -- see slackIdeal, -- computes the
        slack ideal
      * "slackIdeal(Matrix)" -- see slackIdeal, -- computes
        the slack ideal
      * "slackIdeal(Matroid)" -- see slackIdeal, -- computes
        the slack ideal
      * "slackIdeal(Polyhedron)" -- see slackIdeal, --
        computes the slack ideal
      * "slackIdeal(ZZ,List)" -- see slackIdeal, -- computes
        the slack ideal
      * "slackIdeal(ZZ,Matrix)" -- see slackIdeal, --
        computes the slack ideal
      * "slackMatrix(Cone)" -- see slackMatrix, -- computes
        the slack matrix of a given realization
      * "slackMatrix(List)" -- see slackMatrix, -- computes
        the slack matrix of a given realization
      * "slackMatrix(Matroid)" -- see slackMatrix, --
        computes the slack matrix of a given realization
      * "slackMatrix(Polyhedron)" -- see slackMatrix, --
        computes the slack matrix of a given realization
      * "specificSlackMatrix(String)" -- see specificSlackMatrix,
        -- creates built-in slack matrices of some
        polytopes and matroids
      * "symbolicSlackMatrix(Cone)" -- see symbolicSlackMatrix,
        -- computes the symbolic slack matrix
      * "symbolicSlackMatrix(List)" -- see symbolicSlackMatrix,
        -- computes the symbolic slack matrix
      * "symbolicSlackMatrix(Matrix)" -- see symbolicSlackMatrix,
        -- computes the symbolic slack matrix
      * "symbolicSlackMatrix(Matroid)" -- see symbolicSlackMatrix,
        -- computes the symbolic slack matrix
      * "symbolicSlackMatrix(Polyhedron)" -- see symbolicSlackMatrix,
        -- computes the symbolic slack matrix
      * "symbolicSlackOfPlucker(List)" -- see symbolicSlackOfPlucker,
        -- fill the slack matrix with Plücker variables
      * "symbolicSlackOfPlucker(List,List)" -- see
        symbolicSlackOfPlucker, -- fill the slack
        matrix with Plücker variables
      * "symbolicSlackOfPlucker(Matrix)" -- see symbolicSlackOfPlucker,
        -- fill the slack matrix with Plücker variables
      * "symbolicSlackOfPlucker(Matrix,List)" -- see
        symbolicSlackOfPlucker, -- fill the slack
        matrix with Plücker variables
      * "symbolicSlackOfPlucker(Matroid)" -- see symbolicSlackOfPlucker,
        -- fill the slack matrix with Plücker variables
      * "symbolicSlackOfPlucker(Polyhedron)" -- see
        symbolicSlackOfPlucker, -- fill the slack
        matrix with Plücker variables
      * "symbolicSlackOfPlucker(ZZ,List)" -- see symbolicSlackOfPlucker,
        -- fill the slack matrix with Plücker variables
      * "toricPolytope(Ideal)" -- see toricPolytope, --
        computes the polytope whose toric ideal is the given ideal
      * "universalIdeal(List)" -- see universalIdeal, --
        computes the universal realization ideal of a matroid
      * "universalIdeal(Matroid)" -- see universalIdeal,
        -- computes the universal realization ideal of a matroid
  * Symbols
      * FlagElement -- a facet label that will be contained
        in a flag of facets of given polytope or matroid
      * FlagIndices -- a list of facet labels that form a
        flag of facets of given polytope or matroid
      * Object -- select the combinatorial object which the
        input should be interpreted as
      * Saturate -- choose whether to saturate with respect to
        the product of all variables at the same time or variable by variable.
      * Tolerance -- choose the tolerance to approximate
        computations over the field RR
      * Vars -- give a set of variables for the polynomial ring
        where the object created will live

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

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

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

The source of this document is in SlackIdeals.m2:1505:0.

containsFlag -- establishes whether or not a list of facet labels contains a flag in a polytope or matroid
**********************************************************************************************************

  * Usage:
        containsFlag(fl, P)
        containsFlag(fl, M)
        containsFlag(fl, S)
        containsFlag(fl, V)
  * Inputs:
      * fl, a list (Macaulay2Doc), a list of facet labels
      * P, a convex polyhedron (Polyhedra), a polytope
      * M, a matroid (Matroids), a matroid
      * S, a matrix (Macaulay2Doc), (symbolic) slack matrix
      * V, a list (Macaulay2Doc), a list of vertex coordinates,
        matroid vectors, facet labels, or cone generators
  * Optional inputs (Macaulay2Doc),:
      * Object, => ...,
        default value "polytope", specify combinatorial object
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether or not a list of
        facet labels contains a flag in a polytope or matroid

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

Given a list of facet labels fl and a polytope, a matroid, a (symbolic) slack
matrix or a list of vertex coordinates, matroid vectors, facet labels,
establishes whether or not fl contains a flag in the given object.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0, 0}, {0, 0, 1}, {1, 0, 0}, {1, 0, 1}, {0, 1, 0}, {0, 1, 1}}; |
+-----------------------------------------------------------------------------+
|i2 : containsFlag({0, 1, 2, 4}, V)                                           |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {0, 1, 1}}           |
|                                                                             |
|o2 = true                                                                    |
+-----------------------------------------------------------------------------+
|i3 : containsFlag({0, 1, 2, 8}, V, Object => "matroid")                      |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : containsFlag({0, 1, 2, 3}, {{0, 2, 3, 5}, {0, 1, 3, 4}, {1, 2, 4, 5},   |
|                                                                             |
|o4 = true                                                                    |
|-----------------------------------------------------------------------------|
|{0, 1, 2}, {3, 4, 5}}, Object => "abstractPolytope")                         |
+-----------------------------------------------------------------------------+

See also
========

  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope
  * reducedSlackMatrix -- a reduced slack matrix of
    a polytope

Ways to use containsFlag:
=========================

  * "containsFlag(List,List)"
  * "containsFlag(List,Matrix)"
  * "containsFlag(List,Matroid)"
  * "containsFlag(List,Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:2376:0.

containsFlag(...,Object=>...) -- specify combinatorial object
*************************************************************

  * Usage:
        containsFlag(..., Object => "polytope")
        containsFlag(..., Object => "matroid")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: containsFlag, -- establishes whether or not a
    list of facet labels contains a flag in a polytope or matroid
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2650:0.

cycleIdeal -- constructs the cycle ideal of a realization
*********************************************************

  * Usage:
        C = cycleIdeal V
        C = cycleIdeal M
        C = cycleIdeal P
        C = cycleIdeal S
  * Inputs:
      * V, a list (Macaulay2Doc), a list of points of a realization
      * M, a matroid (Matroids), a matroid
      * P, a convex polyhedron (Polyhedra), a polytope
      * S, a matrix (Macaulay2Doc), a slack matrix of some
        realization
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ..., default
        value QQ, specifies the coefficient ring of the underlying ring of the
        ideal
      * Object, => ...,
        default value "polytope", specify combinatorial object
      * Saturate, =>
        ..., default value "all", specifies saturation strategy to be used
      * Strategy, =>
        ..., default value Eliminate, specifies saturation strategy to be used
      * Vars, => ...,
        default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * C, an ideal (Macaulay2Doc), the cycle ideal with
        coefficients from given realization

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

A cycle ideal is the toric ideal generated by the cycles of the bipartite
non-incidence graph on vertices/elements and facets/hyperplanes. Each cycle
binomial has coefficients coming from the entries of a slack matrix of a
realization of the given object. This method computes the cycle ideal of the
given realization of a polytope or matroid.

+------------------------------------------------------------------+
|i1 : V = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};                        |
+------------------------------------------------------------------+
|i2 : C = cycleIdeal V                                             |
|                                                                  |
|Order of vertices is                                              |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}                                  |
|Graph computed from symbolic adjacency matrix: | 0   y_1 0   y_2 ||
|                                               | y_3 0   0   y_4 ||
|                                               | 0   y_5 y_6 0   ||
|                                               | y_7 0   y_8 0   ||
|                                                                  |
|o2 = ideal(y y y y  - y y y y )                                   |
|            0 3 5 6    1 2 4 7                                    |
|                                                                  |
|o2 : Ideal of QQ[y ..y ]                                          |
|                  0   7                                           |
+------------------------------------------------------------------+

You can create the cycle ideal of any matrix, even if it is not the realization
of some matroid or polytope.

+--------------------------------------------------------------+
|i3 : M = matrix{{1, 1, 0}, {0, 1, 2}, {1, 0, 3}};             |
|                                                              |
|              3       3                                       |
|o3 : Matrix ZZ  <-- ZZ                                        |
+--------------------------------------------------------------+
|i4 : C = cycleIdeal M                                         |
|Graph computed from symbolic adjacency matrix: | y_1 y_2 0   ||
|                                               | 0   y_3 y_4 ||
|                                               | y_5 0   y_6 ||
|                                                              |
|o4 = ideal(3y y y  - 2y y y )                                 |
|             1 3 4     0 2 5                                  |
|                                                              |
|o4 : Ideal of QQ[y ..y ]                                      |
|                  0   5                                       |
+--------------------------------------------------------------+

Caveat
======

Variables in the cycle ideal C will be labelled according to the labeling
assigned by symbolicSlackMatrix, which is in order
by rows, so to test equality of C with some precomputed ideal care needs to be
taken that variable labels match.

If Object, => abstractPolytope is chosen, the graphic ideal will
be returned instead.

See also
========

  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * slackMatrix -- computes the slack matrix of a given
    realization

Ways to use cycleIdeal:
=======================

  * "cycleIdeal(List)"
  * "cycleIdeal(Matrix)"
  * "cycleIdeal(Matroid)"
  * "cycleIdeal(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:2109:0.

cycleIdeal(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
**********************************************************************************************************

  * Usage:
        cycleIdeal(..., CoefficientRing => QQ)
        cycleIdeal(..., CoefficientRing => ZZ/7)
        cycleIdeal(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: cycleIdeal, -- constructs the cycle ideal of a
    realization
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2882:0.

cycleIdeal(...,Object=>...) -- specify combinatorial object
***********************************************************

  * Usage:
        cycleIdeal(..., Object => "polytope")
        cycleIdeal(..., Object => "matroid")
        cycleIdeal(..., Object => "abstractPolytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: cycleIdeal, -- constructs the cycle ideal of a
    realization
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2591:0.

cycleIdeal(...,Saturate=>...) -- specifies saturation strategy to be used
*************************************************************************

  * Usage:
        cycleIdeal(..., Saturate => "all")
        cycleIdeal(..., Saturate => "each")

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

  * Default value: all
  * Function: cycleIdeal, -- constructs the cycle ideal of a
    realization
  * Option key: Saturate, -- choose whether to saturate with
    respect to the product of all variables at the same time or variable by
    variable.
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2817:0.

cycleIdeal(...,Strategy=>...) -- specifies saturation strategy to be used
*************************************************************************

  * Usage:
        cycleIdeal(..., Strategy => Iterate)
        cycleIdeal(..., Strategy => Bayer)
        cycleIdeal(..., Strategy => Linear)
        cycleIdeal(..., Strategy => Eliminate)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

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
  * cycleIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * 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)
  * "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
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * graphicIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "greeneKleitmanPartition(...,Strategy=>...)" -- see
    greeneKleitmanPartition (Posets), -- computes the
    Greene-Kleitman partition of a poset
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hasMinor(...,Strategy=>...)" -- see hasMinor (Matroids), --
    whether a matroid has a given minor
  * hermite(...,Strategy=>...) (missing documentation)
  * "hibiRing(...,Strategy=>...)" -- see hibiRing (Posets), --
    produces the Hibi ring of a poset
  * "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
  * "isIsomorphic(...,Strategy=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * isomorphism(...,Strategy=>...) (missing documentation)
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * "lcmLattice(...,Strategy=>...)" -- see lcmLattice (Posets),
    -- generates the lattice of lcms in an ideal
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pPartitionRing(...,Strategy=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * "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)
  * rehomogenizeIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * slackIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * "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
  * "transitiveOrientation(...,Strategy=>...)" -- see
    transitiveOrientation (Posets), -- generates a poset
    whose comparability graph is the given graph

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

  * Default value: Eliminate (Macaulay2Doc),
  * Function: cycleIdeal, -- constructs the cycle ideal of a
    realization
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2706:0.

cycleIdeal(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
******************************************************************************************************

  * Usage:
        cycleIdeal(..., Vars => vars(13..54))
        cycleIdeal(..., Vars => {x_(1, 1)..x_(4, 5)})
        cycleIdeal(..., Vars => {y_3..y_9})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: cycleIdeal, -- constructs the cycle ideal of a
    realization
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3004:0.

findFlag -- computes a list of facet labels that make up a flag in a polytope
*****************************************************************************

  * Usage:
        F = findFlag P
        F = findFlag M
        F = findFlag S
        F = findFlag V
  * Inputs:
      * P, a convex polyhedron (Polyhedra), a polytope
      * M, a matroid (Matroids), a matroid
      * S, a matrix (Macaulay2Doc), (symbolic) slack matrix
      * V, a list (Macaulay2Doc), a list of vertex coordinates,
        matroid vectors, facet labels, or cone generators
  * Optional inputs (Macaulay2Doc),:
      * FlagElement, =>
        ..., default value 0, a facet label that will be contained in a flag of
        facets of given polytope or matroid
      * Object, => ...,
        default value "polytope", specify combinatorial object
  * Outputs:
      * F, a list (Macaulay2Doc), a list of facet labels or
        hyperplanes or column labels or labels that make up a flag in the given
        polytope or matroid or matrix or object given by V

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

Given a polytope, a matroid, a cone, it finds a flag of facets or hyperplanes
or cone generators that can be given as input to obtain a reduced slack matrix.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0, 0}, {0, 0, 1}, {1, 0, 0}, {1, 0, 1}, {0, 1, 0}, {0, 1, 1}}; |
+-----------------------------------------------------------------------------+
|i2 : findFlag V                                                              |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {0, 1, 1}}           |
|Order of facets is                                                           |
|{{0, 2, 3, 5}, {0, 1, 3, 4}, {1, 2, 4, 5}, {0, 1, 2}, {3, 4, 5}}             |
|                                                                             |
|o2 = {0, 1, 2, 4}                                                            |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : findFlag(V, Object => "matroid")                                        |
|                                                                             |
|Order of hyperplanes is                                                      |
|{{2, 3, 4, 5}, {0, 1, 4, 5}, {1, 3, 5}, {0, 3, 5}, {1, 2, 5}, {0, 2, 5}, {1, |
|                                                                             |
|o3 = {0, 1, 5, 7}                                                            |
|                                                                             |
|o3 : List                                                                    |
|-----------------------------------------------------------------------------|
|3, 4}, {0, 3, 4}, {1, 2, 4}, {0, 2, 4}, {0, 1, 2, 3}}                        |
+-----------------------------------------------------------------------------+
|i4 : findFlag({{0, 2, 3, 5}, {0, 1, 3, 4}, {1, 2, 4, 5}, {0, 1, 2}, {3, 4,   |
|Order of facets is                                                           |
|{{0, 2, 3, 5}, {0, 1, 3, 4}, {1, 2, 4, 5}, {0, 1, 2}, {3, 4, 5}}             |
|                                                                             |
|o4 = {0, 1, 2, 4}                                                            |
|                                                                             |
|o4 : List                                                                    |
|-----------------------------------------------------------------------------|
|5}}, Object => "abstractPolytope")                                           |
+-----------------------------------------------------------------------------+

See also
========

  * reconstructSlackMatrix -- a list of facet
    labels that make up a flag in a polytope
  * reducedSlackMatrix -- a reduced slack matrix of
    a polytope

Ways to use findFlag:
=====================

  * "findFlag(List)"
  * "findFlag(Matrix)"
  * "findFlag(Matroid)"
  * "findFlag(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:2335:0.

findFlag(...,FlagElement=>...) -- a facet label that will be contained in a flag of facets of given polytope or matroid
***********************************************************************************************************************

  * Usage:
        findFlag(..., FlagElement => 3)

See also
========

  * Object -- select the combinatorial object which the input
    should be interpreted as

Functions with optional argument named FlagElement:
===================================================

  * findFlag(...,FlagElement=>...)
    -- a facet label that
    will be contained in a flag of facets of given polytope or matroid

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

  * Default value: 0
  * Function: findFlag, -- computes a list of facet labels that
    make up a flag in a polytope
  * Option key: FlagElement, -- a facet label that will be
    contained in a flag of facets of given polytope or matroid
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3112:0.

findFlag(...,Object=>...) -- specify combinatorial object
*********************************************************

  * Usage:
        findFlag(..., Object => "polytope")
        findFlag(..., Object => "matroid")
        findFlag(..., Object => "abstractPolytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: findFlag, -- computes a list of facet labels that
    make up a flag in a polytope
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2636:0.

FlagElement -- a facet label that will be contained in a flag of facets of given polytope or matroid
****************************************************************************************************

  * Usage:
        findFlag(V, FlagElement => 3)

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

The default value is 0.

See also
========

  * Object -- select the combinatorial object which the input
    should be interpreted as
  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope

Functions with optional argument named FlagElement:
===================================================

  * findFlag(...,FlagElement=>...)
    -- a facet label that
    will be contained in a flag of facets of given polytope or matroid

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

The object FlagElement, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:3101:0.

FlagIndices -- a list of facet labels that form a flag of facets of given polytope or matroid
*********************************************************************************************

  * Usage:
        containsFlag(V, FlagIndices => {0, 1, 2, 3})

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

The default value is 0.

See also
========

  * Object -- select the combinatorial object which the input
    should be interpreted as
  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope

Functions with optional argument named FlagIndices:
===================================================

  * reducedSlackMatrix(...,FlagIndices=>...)
    -- a list of
    facet labels that form a flag of facets of given polytope or matroid

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

The object FlagIndices, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:3128:0.

getFacetBases -- get a list of d-spanning elements for each facet
*****************************************************************

  * Usage:
        (newV, B) = getFacetBases S
        (newV, B) = getFacetBases P
        (newV, B) = getFacetBases M
        (newV, B) = getFacetBases V
  * Inputs:
      * S, a matrix (Macaulay2Doc), a slack matrix S of rank d+1
      * P, a convex polyhedron (Polyhedra), a polytope
      * M, a matroid (Matroids), a matroid
      * V, a list (Macaulay2Doc), a list of vertices of d-polytope,
        vectors of a rank d+1 matroid, or (d+1)-cone generators
  * Optional inputs (Macaulay2Doc),:
      * Object, => ...,
        default value "polytope", specify combinatorial object
  * Outputs:
      * newV, a list (Macaulay2Doc), a list of vertices (empty if a
        matrix is given as input) in the order corresponding to B
      * B, a list (Macaulay2Doc), list of d spanning elements for
        each facet

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

This function produces a list B of d spanning elements for each facet in a
given d-polytope, rank d+1 matroid, or (d+1)-cone generators. If a slack matrix
or a list of vertices is given as input, it also creates a sorted list of
vertices (empty if a matrix is given as input) from which B is computed in the
order corresponding to B.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0}, {1, 0}, {2, 1}, {1, 2}, {0, 1}};                           |
+-----------------------------------------------------------------------------+
|i2 : (newV, B) = getFacetBases V                                             |
|                                                                             |
|o2 = ({{0, 0}, {1, 0}, {0, 1}, {2, 1}, {1, 2}}, {{0, 2}, {0, 1}, {1, 3}, {2, |
|     ------------------------------------------------------------------------|
|     4}, {3, 4}})                                                            |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+
+-------------------------------------------+
|i3 : V = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; |
+-------------------------------------------+
|i4 : S = slackMatrix V;                    |
|                                           |
|Order of vertices is                       |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}           |
|                                           |
|              4       4                    |
|o4 : Matrix QQ  <-- QQ                     |
+-------------------------------------------+
|i5 : (newV, B) = getFacetBases S           |
|                                           |
|o5 = ({}, {{0, 2}, {1, 3}, {0, 1}, {2, 3}})|
|                                           |
|o5 : Sequence                              |
+-------------------------------------------+

See also
========

  * slackFromPlucker -- fill the slack matrix of a
    given polytope, cone or matroid with Plücker coordinates
  * symbolicSlackOfPlucker -- fill the slack
    matrix with Plücker variables
  * grassmannSectionIdeal -- compute the
    Grassmannian section ideal corresponding to a slack matrix

Ways to use getFacetBases:
==========================

  * "getFacetBases(List)"
  * "getFacetBases(Matrix)"
  * "getFacetBases(Matroid)"
  * "getFacetBases(Polyhedron)"

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

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

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

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

getFacetBases(...,Object=>...) -- specify combinatorial object
**************************************************************

  * Usage:
        getFacetBases(..., Object => "polytope")
        getFacetBases(..., Object => "cone")
        getFacetBases(..., Object => "matroid")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: getFacetBases, -- get a list of d-spanning
    elements for each facet
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2606:0.

graphFromSlackMatrix -- creates the vertex-edge incidence matrix for the bipartite non-incidence graph with adjacency matrix the given slack matrix
***************************************************************************************************************************************************

  * Usage:
        A = graphFromSlackMatrix S
  * Inputs:
      * S, a matrix (Macaulay2Doc), a (symbolic) slack matrix
  * Outputs:
      * A, a matrix (Macaulay2Doc), 0-1 vertex-edge incidence
        matrix

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

This function creates a matrix whose columns correspond to the edges of the
non-incidence graph of a slack matrix. They are ordered by variable index. The
first n rows correspond to rows of the slack matrix (vertices/ground set
elements) and the remaining rows correspond to columns of the slack matrix
(facets/hyperplanes).

+------------------------------------------------------------------+
|i1 : V = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};                        |
+------------------------------------------------------------------+
|i2 : S = symbolicSlackMatrix V                                    |
|                                                                  |
|Order of vertices is                                              |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}                                  |
|                                                                  |
|o2 = | 0   x_0 0   x_1 |                                          |
|     | x_2 0   0   x_3 |                                          |
|     | 0   x_4 x_5 0   |                                          |
|     | x_6 0   x_7 0   |                                          |
|                                                                  |
|                        4                 4                       |
|o2 : Matrix (QQ[x ..x ])  <-- (QQ[x ..x ])                        |
|                 0   7             0   7                          |
+------------------------------------------------------------------+
|i3 : A = graphFromSlackMatrix S                                   |
|Graph computed from symbolic adjacency matrix: | 0   y_1 0   y_2 ||
|                                               | y_3 0   0   y_4 ||
|                                               | 0   y_5 y_6 0   ||
|                                               | y_7 0   y_8 0   ||
|                                                                  |
|o3 = | 1 1 0 0 0 0 0 0 |                                          |
|     | 0 0 1 1 0 0 0 0 |                                          |
|     | 0 0 0 0 1 1 0 0 |                                          |
|     | 0 0 0 0 0 0 1 1 |                                          |
|     | 0 0 1 0 0 0 1 0 |                                          |
|     | 1 0 0 0 1 0 0 0 |                                          |
|     | 0 0 0 0 0 1 0 1 |                                          |
|     | 0 1 0 1 0 0 0 0 |                                          |
|                                                                  |
|              8       8                                           |
|o3 : Matrix ZZ  <-- ZZ                                            |
+------------------------------------------------------------------+

Caveat
======

If S is not a symbolic slack matrix, the columns of A will be ordered assuming
edges are listed in order by rows of S (as in symbolicSlackMatrix).

See also
========

  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use graphFromSlackMatrix:
=================================

  * "graphFromSlackMatrix(Matrix)"

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

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

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

The source of this document is in SlackIdeals.m2:2013:0.

graphicIdeal -- creates the toric ideal of the non-incidence graph of a polytope
********************************************************************************

  * Usage:
        T = graphicIdeal V
        T = graphicIdeal P
        T = graphicIdeal S
        T = graphicIdeal M
  * Inputs:
      * V, a list (Macaulay2Doc), a list of vertices or of facet
        sets
      * P, a convex polyhedron (Polyhedra), a polytope
      * S, a matrix (Macaulay2Doc), a (symbolic) slack matrix of
        a polytope
      * M, a matroid (Matroids), a matroid
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ...,
        default value QQ, specifies the coefficient ring of the underlying ring
        of the ideal
      * Object, => ...,
        default value "polytope", specify combinatorial object
      * Saturate, =>
        ..., default value "all", specifies saturation strategy to be used
      * Strategy, =>
        ..., default value Eliminate, specifies saturation strategy to be used
      * Vars, => ...,
        default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * T, an ideal (Macaulay2Doc), the toric ideal of the
        non-incidence graph

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

The graphic ideal associated to a polytope is the toric ideal of the vector
configuration consisting of the columns of the vertex-edge incidence matrix of
the non-incidence (of vertices and facets) graph of the polytope.

+------------------------------------------------------------------+
|i1 : P = convexHull(matrix{{0, 0, 1, 1}, {0, 1, 0, 1}});          |
+------------------------------------------------------------------+
|i2 : T = graphicIdeal P                                           |
|                                                                  |
|Order of vertices is                                              |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}                                  |
|Graph computed from symbolic adjacency matrix: | 0   y_1 0   y_2 ||
|                                               | y_3 0   0   y_4 ||
|                                               | 0   y_5 y_6 0   ||
|                                               | y_7 0   y_8 0   ||
|                                                                  |
|o2 = ideal(y y y y  - y y y y )                                   |
|            0 3 5 6    1 2 4 7                                    |
|                                                                  |
|o2 : Ideal of QQ[y ..y ]                                          |
|                  0   7                                           |
+------------------------------------------------------------------+

Caveat
======

If S is not a symbolic slack matrix, the ideal will have variables indexed as
in symbolicSlackMatrix, (from left to right in order
by rows of S).

See also
========

  * graphFromSlackMatrix -- creates the
    vertex-edge incidence matrix for the bipartite non-incidence graph with
    adjacency matrix the given slack matrix
  * cycleIdeal -- constructs the cycle ideal of a
    realization
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use graphicIdeal:
=========================

  * "graphicIdeal(List)"
  * "graphicIdeal(Matrix)"
  * "graphicIdeal(Matroid)"
  * "graphicIdeal(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:2057:0.

graphicIdeal(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
************************************************************************************************************

  * Usage:
        graphicIdeal(..., CoefficientRing => QQ)
        graphicIdeal(..., CoefficientRing => ZZ/7)
        graphicIdeal(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: graphicIdeal, -- creates the toric ideal of
    the non-incidence graph of a polytope
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2895:0.

graphicIdeal(...,Object=>...) -- specify combinatorial object
*************************************************************

  * Usage:
        slackMatrix(..., Object => "polytope")
        slackMatrix(..., Object => "abstractPolytope")

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

Indicates whether an input list should be treated as the vertices of a polytope
or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: graphicIdeal, -- creates the toric ideal of
    the non-incidence graph of a polytope
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2515:0.

graphicIdeal(...,Saturate=>...) -- specifies saturation strategy to be used
***************************************************************************

  * Usage:
        graphicIdeal(..., Saturate => "all")
        graphicIdeal(..., Saturate => "each")

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

  * Default value: all
  * Function: graphicIdeal, -- creates the toric ideal of
    the non-incidence graph of a polytope
  * Option key: Saturate, -- choose whether to saturate with
    respect to the product of all variables at the same time or variable by
    variable.
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2805:0.

graphicIdeal(...,Strategy=>...) -- specifies saturation strategy to be used
***************************************************************************

  * Usage:
        cycleIdeal(..., Strategy => Iterate)
        cycleIdeal(..., Strategy => Bayer)
        cycleIdeal(..., Strategy => Linear)
        cycleIdeal(..., Strategy => Eliminate)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

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
  * cycleIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * 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)
  * "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
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * graphicIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "greeneKleitmanPartition(...,Strategy=>...)" -- see
    greeneKleitmanPartition (Posets), -- computes the
    Greene-Kleitman partition of a poset
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hasMinor(...,Strategy=>...)" -- see hasMinor (Matroids), --
    whether a matroid has a given minor
  * hermite(...,Strategy=>...) (missing documentation)
  * "hibiRing(...,Strategy=>...)" -- see hibiRing (Posets), --
    produces the Hibi ring of a poset
  * "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
  * "isIsomorphic(...,Strategy=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * isomorphism(...,Strategy=>...) (missing documentation)
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * "lcmLattice(...,Strategy=>...)" -- see lcmLattice (Posets),
    -- generates the lattice of lcms in an ideal
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pPartitionRing(...,Strategy=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * "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)
  * rehomogenizeIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * slackIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * "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
  * "transitiveOrientation(...,Strategy=>...)" -- see
    transitiveOrientation (Posets), -- generates a poset
    whose comparability graph is the given graph

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

  * Default value: Eliminate (Macaulay2Doc),
  * Function: graphicIdeal, -- creates the toric ideal of
    the non-incidence graph of a polytope
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2720:0.

graphicIdeal(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
********************************************************************************************************

  * Usage:
        graphicIdeal(..., Vars => {x_0..x_19})
        graphicIdeal(..., Vars => {y_(1, 1)..y_(3, 2)})
        graphicIdeal(..., Vars => {a..k})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: graphicIdeal, -- creates the toric ideal of
    the non-incidence graph of a polytope
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3018:0.

grassmannSectionIdeal -- compute the Grassmannian section ideal corresponding to a slack matrix
***********************************************************************************************

  * Usage:
        I = grassmannSectionIdeal(S, B)
        I = grassmannSectionIdeal S
        I = grassmannSectionIdeal(V, B)
        I = grassmannSectionIdeal V
        I = grassmannSectionIdeal P
        I = grassmannSectionIdeal C
        I = grassmannSectionIdeal M
  * Inputs:
      * S, a matrix (Macaulay2Doc), slack matrix
      * B, a list (Macaulay2Doc), set of hyperplane spanning set
        indices
      * V, a list (Macaulay2Doc), list of polytope vertex
        coordinates, cone generators, or matroid vectors
      * P, a convex polyhedron (Polyhedra), a polytope
      * C, a convex rational cone (Polyhedra), a cone
      * M, a matroid (Matroids), a matroid
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        =>
        ..., default value QQ, specifies the coefficient ring of the underlying
        ring of the ideal
      * Object,
        => ..., default value "polytope", specify combinatorial object
      * Saturate,
        => ..., default value "all", specifies saturation strategy to be
        used
      * Strategy,
        => ..., default value Eliminate, specifies saturation strategy to
        be used
  * Outputs:
      * I, an ideal (Macaulay2Doc), the Grassmannian section ideal
        corresponding to choice B of the object with slack matrix S

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

Given a slack matrix of a polytope, a cone or a matroid, or a set of polytope
vertices, cone generators, or matroid vectors, and a set of set of hyperplane
spanning set indices, it computes the Grassmannian section ideal corresponding
to choice B of the object with slack matrix S.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0}, {1, 0}, {2, 1}, {1, 2}, {0, 1}};                           |
+-----------------------------------------------------------------------------+
|i2 : (VV, B) = getFacetBases V;                                              |
+-----------------------------------------------------------------------------+
|i3 : I = grassmannSectionIdeal(VV, B)                                        |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0}, {1, 0}, {0, 1}, {2, 1}, {1, 2}}                                     |
|                                                                             |
|o3 = ideal (p     p      - p     p      + p     p     , p     p      -       |
|             1,2,4 0,3,4    0,2,4 1,3,4    0,1,4 2,3,4   1,2,3 0,3,4         |
|     ------------------------------------------------------------------------|
|     p     p      + p     p     , p     p      - p     p      + p     p     ,|
|      0,2,3 1,3,4    0,1,3 2,3,4   1,2,3 0,2,4    0,2,3 1,2,4    0,1,2 2,3,4 |
|     ------------------------------------------------------------------------|
|     p     p      - p     p      + p     p     , p     p      - p     p      |
|      1,2,3 0,1,4    0,1,3 1,2,4    0,1,2 1,3,4   0,2,3 0,1,4    0,1,3 0,2,4 |
|     ------------------------------------------------------------------------|
|     + p     p     )                                                         |
|        0,1,2 0,3,4                                                          |
|                                                                             |
|o3 : Ideal of QQ[p     ..p     , p     , p     , p     , p     , p     , p   |
|                  0,1,2   0,1,3   0,2,3   1,2,3   0,1,4   0,2,4   1,2,4   0,3|
|-----------------------------------------------------------------------------|
|  , p     , p     ]                                                          |
|,4   1,3,4   2,3,4                                                           |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i4 : V = {{0, 0}, {1, 0}, {2, 1}, {1, 2}, {0, 1}};                           |
+-----------------------------------------------------------------------------+
|i5 : (VV, B) = getFacetBases V;                                              |
+-----------------------------------------------------------------------------+
|i6 : I = grassmannSectionIdeal(slackMatrix(VV), B)                           |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0}, {1, 0}, {0, 1}, {2, 1}, {1, 2}}                                     |
|                                                                             |
|o6 = ideal (p     p      - p     p      + p     p     , p     p      -       |
|             1,2,4 0,3,4    0,2,4 1,3,4    0,1,4 2,3,4   1,2,3 0,3,4         |
|     ------------------------------------------------------------------------|
|     p     p      + p     p     , p     p      - p     p      + p     p     ,|
|      0,2,3 1,3,4    0,1,3 2,3,4   1,2,3 0,2,4    0,2,3 1,2,4    0,1,2 2,3,4 |
|     ------------------------------------------------------------------------|
|     p     p      - p     p      + p     p     , p     p      - p     p      |
|      1,2,3 0,1,4    0,1,3 1,2,4    0,1,2 1,3,4   0,2,3 0,1,4    0,1,3 0,2,4 |
|     ------------------------------------------------------------------------|
|     + p     p     )                                                         |
|        0,1,2 0,3,4                                                          |
|                                                                             |
|o6 : Ideal of QQ[p     ..p     , p     , p     , p     , p     , p     , p   |
|                  0,1,2   0,1,3   0,2,3   1,2,3   0,1,4   0,2,4   1,2,4   0,3|
|-----------------------------------------------------------------------------|
|  , p     , p     ]                                                          |
|,4   1,3,4   2,3,4                                                           |
+-----------------------------------------------------------------------------+

See also
========

  * getFacetBases -- get a list of d-spanning elements
    for each facet
  * slackFromPlucker -- fill the slack matrix of a
    given polytope, cone or matroid with Plücker coordinates
  * slackFromGalePlucker -- fill the slack matrix
    with Plücker coordinates of the Gale transform
  * symbolicSlackOfPlucker -- fill the slack
    matrix with Plücker variables

Ways to use grassmannSectionIdeal:
==================================

  * "grassmannSectionIdeal(Cone)"
  * "grassmannSectionIdeal(List)"
  * "grassmannSectionIdeal(List,List)"
  * "grassmannSectionIdeal(Matrix)"
  * "grassmannSectionIdeal(Matrix,List)"
  * "grassmannSectionIdeal(Matroid)"
  * "grassmannSectionIdeal(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:1980:0.

grassmannSectionIdeal(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
*********************************************************************************************************************

  * Usage:
        grassmannSectionIdeal(..., CoefficientRing => QQ)
        grassmannSectionIdeal(..., CoefficientRing => ZZ/7)
        grassmannSectionIdeal(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: grassmannSectionIdeal, -- compute
    the Grassmannian section ideal corresponding to a slack matrix
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2869:0.

grassmannSectionIdeal(...,Object=>...) -- specify combinatorial object
**********************************************************************

  * Usage:
        grassmannSectionIdeal(..., Object => "cone")
        grassmannSectionIdeal(..., Object => "matroid")
        grassmannSectionIdeal(..., Object => "polytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: grassmannSectionIdeal, -- compute
    the Grassmannian section ideal corresponding to a slack matrix
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2576:0.

grassmannSectionIdeal(...,Saturate=>...) -- specifies saturation strategy to be used
************************************************************************************

  * Usage:
        grassmannSectionIdeal(..., Saturate => "all")
        grassmannSectionIdeal(..., Saturate => "each")

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

  * Default value: all
  * Function: grassmannSectionIdeal, -- compute
    the Grassmannian section ideal corresponding to a slack matrix
  * Option key: Saturate, -- choose whether to saturate with
    respect to the product of all variables at the same time or variable by
    variable.
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2793:0.

grassmannSectionIdeal(...,Strategy=>...) -- specifies saturation strategy to be used
************************************************************************************

  * Usage:
        grassmannSectionIdeal(..., Strategy => Iterate)
        grassmannSectionIdeal(..., Strategy => Bayer)
        grassmannSectionIdeal(..., Strategy => Linear)
        grassmannSectionIdeal(..., Strategy => Eliminate)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

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
  * cycleIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * 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)
  * "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
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * graphicIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "greeneKleitmanPartition(...,Strategy=>...)" -- see
    greeneKleitmanPartition (Posets), -- computes the
    Greene-Kleitman partition of a poset
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hasMinor(...,Strategy=>...)" -- see hasMinor (Matroids), --
    whether a matroid has a given minor
  * hermite(...,Strategy=>...) (missing documentation)
  * "hibiRing(...,Strategy=>...)" -- see hibiRing (Posets), --
    produces the Hibi ring of a poset
  * "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
  * "isIsomorphic(...,Strategy=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * isomorphism(...,Strategy=>...) (missing documentation)
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * "lcmLattice(...,Strategy=>...)" -- see lcmLattice (Posets),
    -- generates the lattice of lcms in an ideal
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pPartitionRing(...,Strategy=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * "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)
  * rehomogenizeIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * slackIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * "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
  * "transitiveOrientation(...,Strategy=>...)" -- see
    transitiveOrientation (Posets), -- generates a poset
    whose comparability graph is the given graph

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

  * Default value: Eliminate (Macaulay2Doc),
  * Function: grassmannSectionIdeal, -- compute
    the Grassmannian section ideal corresponding to a slack matrix
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2692:0.

Object -- select the combinatorial object which the input should be interpreted as
**********************************************************************************

  * Usage:
        slackMatrix(V, Object => "matroid")
        slackIdeal(V, Object => "abstractPolytope")
        symbolicSlackMatrix(V, Object => "polytope")
        cycleIdeal(V, Object => "matroid")
        graphicIdeal(V, Object => "abstractPolytope")
        getFacetBases(V, Object => "cone")
        slackFromPlucker(V, Object => "polytope")
        symbolicSlackOfPlucker(V, Object => "matroid")
        grassmannSectionIdeal(V, Object => "cone")
        findFlag(V, Object => "matroid")
        containsFlag(fl, V, Object => "matroid")
        reducedSlackMatrix(V, Object => "polytope")

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

The default value is polytope.

See also
========

  * slackMatrix -- computes the slack matrix of a given
    realization
  * slackIdeal -- computes the slack ideal
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix
  * cycleIdeal -- constructs the cycle ideal of a
    realization
  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * getFacetBases -- get a list of d-spanning elements
    for each facet
  * slackFromPlucker -- fill the slack matrix of a
    given polytope, cone or matroid with Plücker coordinates
  * symbolicSlackOfPlucker -- fill the slack
    matrix with Plücker variables
  * grassmannSectionIdeal -- compute the
    Grassmannian section ideal corresponding to a slack matrix
  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope
  * containsFlag -- establishes whether or not a list of
    facet labels contains a flag in a polytope or matroid
  * reducedSlackMatrix -- a reduced slack matrix of
    a polytope

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

The object Object, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:2487:0.

reconstructSlackMatrix -- a list of facet labels that make up a flag in a polytope
**********************************************************************************

  * Usage:
        ExtS = reconstructSlackMatrix(S, fl, F)
        ExtS = reconstructSlackMatrix(S, F)
  * Inputs:
      * S, a matrix (Macaulay2Doc), a (column) reduced slack
        matrix
      * fl, a list (Macaulay2Doc), a flag of columns
      * F, a list (Macaulay2Doc), list of facet columns we want to
        refill
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        =>
        ..., default value QQ, specifies the coefficient ring of the underlying
        ring of the ideal
      * Vars, =>
        ..., default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * ExtS, a matrix (Macaulay2Doc), S extended by the columns
        of F

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

Given a (column) reduced slack matrix S, a flag of columns and a list of facet
columns F to refill, it extends S by the columns of F.

+-----------------------------------------------------------------------------+
|i1 : V = {{0,0,0},{0,0,1},{1,0,0},{1,0,1},{0,1,0},{0,1,1}};                  |
+-----------------------------------------------------------------------------+
|i2 : S = slackMatrix V;                                                      |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {0, 1, 1}}           |
|                                                                             |
|              6       5                                                      |
|o2 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i3 : redS = reducedSlackMatrix(3, S);                                        |
|                                                                             |
|              6       4                                                      |
|o3 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i4 : reconstructSlackMatrix(reducedSlackMatrix(S,                            |
|                                                                             |
|o4 = | 0 0 a b 0     |                                                       |
|     | c 0 0 d 0     |                                                       |
|     | 0 e 0 f 0     |                                                       |
|     | 0 0 g 0 -bceg |                                                       |
|     | h 0 0 0 -adeh |                                                       |
|     | 0 j 0 0 -acfj |                                                       |
|                                                                             |
|                                  6                                          |
|o4 : Matrix (QQ[a..h, j..k, m, p])  <-- (QQ[a..h,                            |
|-----------------------------------------------------------------------------|
|Vars => {a,b,c,d,e,f,g,h,j,k,m,p}), {{0,1,2}})                               |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|            5                                                                |
|j..k, m, p])                                                                 |
+-----------------------------------------------------------------------------+
|i5 : reconstructSlackMatrix(redS, {{0,1,2}})                                 |
|                                                                             |
|o5 = | 0 0 1 1 0  |                                                          |
|     | 1 0 0 1 0  |                                                          |
|     | 0 1 0 1 0  |                                                          |
|     | 0 0 1 0 -1 |                                                          |
|     | 1 0 0 0 -1 |                                                          |
|     | 0 1 0 0 -1 |                                                          |
|                                                                             |
|              6       5                                                      |
|o5 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i6 : reconstructSlackMatrix(redS, {{0,1,2}}, Vars => {x})                    |
|warning: clearing value of symbol x to allow access to subscripted variables |
|       : debug with expression   debug 9868   or with command line option    |
|                                                                             |
|Not enough variables given. Making new ring for reconstructed matrix         |
|                                                                             |
|o6 = | 0   0   x_0 x_1 0             |                                       |
|     | x_2 0   0   x_3 0             |                                       |
|     | 0   x_4 0   x_5 0             |                                       |
|     | 0   0   x_6 0   -x_1x_2x_4x_6 |                                       |
|     | x_7 0   0   0   -x_0x_3x_4x_7 |                                       |
|     | 0   x_8 0   0   -x_0x_2x_5x_8 |                                       |
|                                                                             |
|                        6                 5                                  |
|o6 : Matrix (QQ[x ..x ])  <-- (QQ[x ..x ])                                   |
|                 0   8             0   8                                     |
|-----------------------------------------------------------------------------|
| based on it                                                                 |
|--debug 9868                                                                 |
+-----------------------------------------------------------------------------+

See also
========

  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope
  * reducedSlackMatrix -- a reduced slack matrix of
    a polytope

Ways to use reconstructSlackMatrix:
===================================

  * "reconstructSlackMatrix(Matrix,List)"
  * "reconstructSlackMatrix(Matrix,List,List)"

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

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

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

The source of this document is in SlackIdeals.m2:2411:0.

reconstructSlackMatrix(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
**********************************************************************************************************************

  * Usage:
        reconstructSlackMatrix(..., CoefficientRing => QQ)
        reconstructSlackMatrix(..., CoefficientRing => ZZ/7)
        reconstructSlackMatrix(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: reconstructSlackMatrix, -- a list
    of facet labels that make up a flag in a polytope
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2921:0.

reconstructSlackMatrix(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
******************************************************************************************************************

  * Usage:
        reconstructSlackMatrix(..., Vars => {x})
        reconstructSlackMatrix(..., Vars => {a,b,c,d,e,f,g,h,j})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: reconstructSlackMatrix, -- a list
    of facet labels that make up a flag in a polytope
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3045:0.

reducedSlackMatrix -- a reduced slack matrix of a polytope
**********************************************************

  * Usage:
        RedS = reducedSlackMatrix(d, S)
        RedS = reducedSlackMatrix S
        RedS = reducedSlackMatrix V
  * Inputs:
      * d, an integer (Macaulay2Doc), the dimension of the polytope
        or 1 less than the rank of the matroid
      * S, a matrix (Macaulay2Doc), a (symbolic) slack matrix of
        a polytope or of a matroid
      * V, a list (Macaulay2Doc), list of vertex coordinates,
        matroid vectors, facet labels, or cone generators
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ...,
        default value QQ, specifies the coefficient ring of the underlying ring
        of the ideal
      * FlagIndices,
        => ..., default value {}, a list of facet labels that form a
        flag of facets of given polytope or matroid
      * Object, =>
        ..., default value "polytope", specify combinatorial object
      * Vars, =>
        ..., default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * RedS, a matrix (Macaulay2Doc), a reduced slack matrix

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

Given a (symbolic) slack matrix of a polytope or of a matroid, or a list of
vertex coordinates, matroid vectors, facet labels, or cone generators, it
reduces it by removing the columns corresponding to simplicial facets outside
of a flag.

+-----------------------------------------------------------------------------+
|i1 : V = {{0,0,0},{0,0,1},{1,0,0},{1,0,1},{0,1,0},{0,1,1}};                  |
+-----------------------------------------------------------------------------+
|i2 : S = slackMatrix V;                                                      |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {0, 1, 1}}           |
|                                                                             |
|              6       5                                                      |
|o2 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i3 : reducedSlackMatrix V                                                    |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {0, 1, 1}}           |
|                                                                             |
|o3 = | 0 0 1 1 |                                                             |
|     | 1 0 0 1 |                                                             |
|     | 0 1 0 1 |                                                             |
|     | 0 0 1 0 |                                                             |
|     | 1 0 0 0 |                                                             |
|     | 0 1 0 0 |                                                             |
|                                                                             |
|              6       4                                                      |
|o3 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i4 : reducedSlackMatrix(3, S)                                                |
|                                                                             |
|o4 = | 0 0 1 1 |                                                             |
|     | 1 0 0 1 |                                                             |
|     | 0 1 0 1 |                                                             |
|     | 0 0 1 0 |                                                             |
|     | 1 0 0 0 |                                                             |
|     | 0 1 0 0 |                                                             |
|                                                                             |
|              6       4                                                      |
|o4 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i5 : R = QQ[x_1..x_30];                                                      |
+-----------------------------------------------------------------------------+
|i6 : S = matrix {{0, 0, x_1, x_2, x_3, 0, x_4}, {x_5, x_6, 0, 0, x_7, x_8,   |
|                                                                             |
|             8      7                                                        |
|o6 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|0}, {0, x_9, 0, x_10, x_11, 0, 0}, {x_12, 0, x_13, 0, x_14, 0, 0}, {0, 0,    |
|-----------------------------------------------------------------------------|
|x_15, x_16, 0, x_17, x_18}, {x_19, x_20, 0, 0, 0, x_21, x_22}, {0, x_23, 0,  |
|-----------------------------------------------------------------------------|
|x_24, 0, x_25, x_26}, {x_27, 0, x_28, 0, 0, x_29, x_30}};                    |
+-----------------------------------------------------------------------------+
|i7 : redS = reducedSlackMatrix(3, S)                                         |
|                                                                             |
|o7 = | 0    0    x_1  x_2  x_3  |                                            |
|     | x_5  x_6  0    0    x_7  |                                            |
|     | 0    x_9  0    x_10 x_11 |                                            |
|     | x_12 0    x_13 0    x_14 |                                            |
|     | 0    0    x_15 x_16 0    |                                            |
|     | x_19 x_20 0    0    0    |                                            |
|     | 0    x_23 0    x_24 0    |                                            |
|     | x_27 0    x_28 0    0    |                                            |
|                                                                             |
|             8      5                                                        |
|o7 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * findFlag -- computes a list of facet labels that make up a
    flag in a polytope
  * reconstructSlackMatrix -- a list of facet
    labels that make up a flag in a polytope

Ways to use reducedSlackMatrix:
===============================

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

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

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

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

The source of this document is in SlackIdeals.m2:2451:0.

reducedSlackMatrix(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
******************************************************************************************************************

  * Usage:
        reducedSlackMatrix(..., CoefficientRing => QQ)
        reducedSlackMatrix(..., CoefficientRing => ZZ/7)
        reducedSlackMatrix(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: reducedSlackMatrix, -- a reduced slack
    matrix of a polytope
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2934:0.

reducedSlackMatrix(...,FlagIndices=>...) -- a list of facet labels that form a flag of facets of given polytope or matroid
**************************************************************************************************************************

  * Usage:
        reducedSlackMatrix(..., FlagIndices => {0, 1, 2, 3})

See also
========

  * Object -- select the combinatorial object which the input
    should be interpreted as

Functions with optional argument named FlagIndices:
===================================================

  * reducedSlackMatrix(...,FlagIndices=>...)
    -- a list of
    facet labels that form a flag of facets of given polytope or matroid

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

  * Default value: {}
  * Function: reducedSlackMatrix, -- a reduced slack
    matrix of a polytope
  * Option key: FlagIndices, -- a list of facet labels that
    form a flag of facets of given polytope or matroid
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3139:0.

reducedSlackMatrix(...,Object=>...) -- specify combinatorial object
*******************************************************************

  * Usage:
        reducedSlackMatrix(..., Object => "polytope")
        reducedSlackMatrix(..., Object => "matroid")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: reducedSlackMatrix, -- a reduced slack
    matrix of a polytope
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2664:0.

reducedSlackMatrix(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
**************************************************************************************************************

  * Usage:
        reducedSlackMatrix(..., Vars => {x})
        reducedSlackMatrix(..., Vars => {a,b,c,d,e,f,g,h,j,k,m,p})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: reducedSlackMatrix, -- a reduced slack
    matrix of a polytope
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3058:0.

rehomogenizeIdeal -- rehomogenization of a the dehomogenized slack ideal
************************************************************************

  * Usage:
        H = rehomogenizeIdeal(d, X)
        H = rehomogenizeIdeal(d, Y, T)
  * Inputs:
      * d, an integer (Macaulay2Doc), dimension of the polytope
      * X, a matrix (Macaulay2Doc), a symbolic slack matrix X of
        a d-polytope
      * Y, a matrix (Macaulay2Doc), dehomogenized symbolic slack
        matrix Y of d-polytope
      * T, a graph (EdgeIdeals), spanning forest whose edges match
        the ones in Y
  * Optional inputs (Macaulay2Doc),:
      * Saturate,
        => ..., default value "all", specifies saturation strategy to be used
      * Strategy,
        => ..., default value Eliminate, specifies saturation strategy to be
        used
  * Outputs:
      * H, an ideal (Macaulay2Doc), the rehomogenization of the
        dehomogenized slack ideal

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

It computes the rehomogenization of the dehomogenized slack ideal, applying the
rehomogenize function to its generators.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {0, 1, 0}, {0, 0, 1}, {0, 1, 1}}; |
+-----------------------------------------------------------------------------+
|i2 : X = symbolicSlackMatrix V                                               |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}, {0, 0, 1}, {0, 1, 1}}           |
|                                                                             |
|o2 = | 0   0    x_0 0    x_1 |                                               |
|     | x_2 0    x_3 0    0   |                                               |
|     | 0   x_4  0   0    x_5 |                                               |
|     | x_6 x_7  0   0    0   |                                               |
|     | 0   0    x_8 x_9  0   |                                               |
|     | 0   x_10 0   x_11 0   |                                               |
|                                                                             |
|                         6                  5                                |
|o2 : Matrix (QQ[x ..x  ])  <-- (QQ[x ..x  ])                                 |
|                 0   11             0   11                                   |
+-----------------------------------------------------------------------------+
|i3 : H = rehomogenizeIdeal(3, X)                                             |
|                                                                             |
|o3 = ideal (x x x x   - x x x x  , x x x x   - x x x x  , x x x x  -         |
|             3 6 9 10    2 7 8 11   0 5 9 10    1 4 8 11   1 3 4 6           |
|     ------------------------------------------------------------------------|
|     x x x x )                                                               |
|      0 2 5 7                                                                |
|                                                                             |
|o3 : Ideal of QQ[x ..x  ]                                                    |
|                  0   11                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i4 : R = QQ[x_0..x_11];                                                      |
+-----------------------------------------------------------------------------+
|i5 : Y = matrix {{0, 0, 1, 0, 1}, {1, 0, 1, 0, 0}, {0, x_4, 0, 0, 1}, {1, 1, |
|                                                                             |
|             6      5                                                        |
|o5 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|0, 0, 0}, {0, 0, 1, 1, 0}, {0, x_10, 0, 1, 0}};                              |
+-----------------------------------------------------------------------------+
|i6 : T = graph(QQ[y_0, y_1, y_2, y_3, y_4, y_5, y_6, y_7, y_8, y_9, y_10],   |
|-----------------------------------------------------------------------------|
|{{y_1, y_6}, {y_3, y_6}, {y_3, y_7}, {y_0, y_8}, {y_1, y_8}, {y_4, y_8},     |
|-----------------------------------------------------------------------------|
|{y_4, y_9}, {y_5, y_9}, {y_0, y_10}, {y_2, y_10}});                          |
+-----------------------------------------------------------------------------+
|i7 : rehomogenizeIdeal(3, Y, T)                                              |
|                                                                             |
|o7 = ideal (x x x x   - x x x x  , x x x x   - x x x x  , x x x x  -         |
|             3 6 9 10    2 7 8 11   0 5 9 10    1 4 8 11   1 3 4 6           |
|     ------------------------------------------------------------------------|
|     x x x x )                                                               |
|      0 2 5 7                                                                |
|                                                                             |
|o7 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * rehomogenizePolynomial -- rehomogenization
    of a polynomial reversing the dehomogenization of the slack matrix
  * setOnesForest -- sets to 1 variables in a symbolic
    slack matrix which corresponding to edges of a spanning forest
  * slackIdeal -- computes the slack ideal
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use rehomogenizeIdeal:
==============================

  * "rehomogenizeIdeal(ZZ,Matrix)"
  * "rehomogenizeIdeal(ZZ,Matrix,Graph)"

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

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

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

The source of this document is in SlackIdeals.m2:2296:0.

rehomogenizeIdeal(...,Saturate=>...) -- specifies saturation strategy to be used
********************************************************************************

  * Usage:
        rehomogenizeIdeal(..., Saturate => "all")
        rehomogenizeIdeal(..., Saturate => "each")

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

  * Default value: all
  * Function: rehomogenizeIdeal, -- rehomogenization
    of a the dehomogenized slack ideal
  * Option key: Saturate, -- choose whether to saturate with
    respect to the product of all variables at the same time or variable by
    variable.
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2781:0.

rehomogenizeIdeal(...,Strategy=>...) -- specifies saturation strategy to be used
********************************************************************************

  * Usage:
        rehomogenizeIdeal(..., Strategy => Iterate)
        rehomogenizeIdeal(..., Strategy => Bayer)
        rehomogenizeIdeal(..., Strategy => Linear)
        rehomogenizeIdeal(..., Strategy => Eliminate)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

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
  * cycleIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * 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)
  * "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
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * graphicIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "greeneKleitmanPartition(...,Strategy=>...)" -- see
    greeneKleitmanPartition (Posets), -- computes the
    Greene-Kleitman partition of a poset
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hasMinor(...,Strategy=>...)" -- see hasMinor (Matroids), --
    whether a matroid has a given minor
  * hermite(...,Strategy=>...) (missing documentation)
  * "hibiRing(...,Strategy=>...)" -- see hibiRing (Posets), --
    produces the Hibi ring of a poset
  * "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
  * "isIsomorphic(...,Strategy=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * isomorphism(...,Strategy=>...) (missing documentation)
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * "lcmLattice(...,Strategy=>...)" -- see lcmLattice (Posets),
    -- generates the lattice of lcms in an ideal
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pPartitionRing(...,Strategy=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * "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)
  * rehomogenizeIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * slackIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * "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
  * "transitiveOrientation(...,Strategy=>...)" -- see
    transitiveOrientation (Posets), -- generates a poset
    whose comparability graph is the given graph

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

  * Default value: Eliminate (Macaulay2Doc),
  * Function: rehomogenizeIdeal, -- rehomogenization
    of a the dehomogenized slack ideal
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2734:0.

rehomogenizePolynomial -- rehomogenization of a polynomial reversing the dehomogenization of the slack matrix
*************************************************************************************************************

  * Usage:
        h = rehomogenizePolynomial X
        h = rehomogenizePolynomial(X, Y, T, g)
  * Inputs:
      * X, a matrix (Macaulay2Doc), a symbolic slack matrix X
      * Y, a matrix (Macaulay2Doc), dehomogenized slack matrix Y
      * T, a graph (EdgeIdeals), a spanning forest of the
        bipartite graph associated to X
      * g, a ring element (Macaulay2Doc), a polynomial
  * Outputs:
      * h, a ring element (Macaulay2Doc), the
        rehomogenization of g reversing the dehomogenization of the slack
        matrix

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

Given the symbolic slack matrix X of a polytope, we may set to 1 the variables
corresponding of a spanning forest of the bipartite graph associated with X. It
can be useful to rehomogenize a polynomial in the variables that are left,
reversing the dehomogenization process.

This function produces the rehomogenization of a polynomial following the
spanning forest backwards. It is useful in the computation of the
rehomogenization of the generators of an ideal, for example of the slack ideal.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_12];                                                      |
+-----------------------------------------------------------------------------+
|i2 : X = matrix {{0, x_1, 0, 0, x_2}, {x_3, 0, 0, 0, x_4}, {0, x_5, x_6, 0,  |
|                                                                             |
|             6      5                                                        |
|o2 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|0}, {x_7, 0, x_8, 0, 0}, {0, x_9, 0, x_10, 0}, {x_11, 0, 0, x_12, 0}};       |
+-----------------------------------------------------------------------------+
|i3 : (Y, T) = setOnesForest X;                                               |
+-----------------------------------------------------------------------------+
|i4 : remVars := flatten entries Y - set{0_(ring Y), 1_(ring Y)};             |
+-----------------------------------------------------------------------------+
|i5 : h = rehomogenizePolynomial(X, Y, T, remVars_0^2+remVars_0*remVars_1-1)  |
|                                                                             |
|      2 2 2 2          2 2 2 2                  2 2                          |
|o5 = x x x x x  x   - x x x x x  x   + x x x x x x x x                       |
|      1 4 6 7 10 11    2 3 5 8 10 11    1 2 3 4 6 7 9 12                     |
|                                                                             |
|o5 : R                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * setOnesForest -- sets to 1 variables in a symbolic
    slack matrix which corresponding to edges of a spanning forest
  * slackIdeal -- computes the slack ideal
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use rehomogenizePolynomial:
===================================

  * "rehomogenizePolynomial(Matrix)"
  * "rehomogenizePolynomial(Matrix,Matrix,Graph,RingElement)"

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

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

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

The source of this document is in SlackIdeals.m2:2254:0.

Saturate -- choose whether to saturate with respect to the product of all variables at the same time or variable by variable.
*****************************************************************************************************************************

  * Usage:
        slackIdeal(V, Saturate => "all")
        rehomogenizeIdeal(d, X, Saturate => "each")
        grassmannSectionIdeal(S, B, Saturate => "all")
        graphicIdeal(V, Saturate => "each")
        cycleIdeal(S, Saturate => "all")

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

The default value is "all".

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument
  * slackIdeal -- computes the slack ideal
  * rehomogenizeIdeal -- rehomogenization of a the
    dehomogenized slack ideal
  * grassmannSectionIdeal -- compute the
    Grassmannian section ideal corresponding to a slack matrix
  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * cycleIdeal -- constructs the cycle ideal of a
    realization

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

The object Saturate, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:2757:0.

setOnesForest -- sets to 1 variables in a symbolic slack matrix which corresponding to edges of a spanning forest
*****************************************************************************************************************

  * Usage:
        (Y, F) = setOnesForest X
  * Inputs:
      * X, a matrix (Macaulay2Doc), a symbolic slack matrix
  * Outputs:
      * Y, a matrix (Macaulay2Doc), the matrix X with the
        variables corresponding to the edges of a spanning forest set to 1
      * F, a graph (EdgeIdeals), spanning forest of the bipartite
        (non-incidence) graph whose vertices are the vertices and facets of a
        polytope P, and whose edges are the vertex-facet pairs of P such that
        the vertex is not on the facet

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

Since row and column scaling operations preserve the projective equivalence
class of a slack matrix, it is sometimes advantageous to choose a certain
equivalence class representative by setting some variables in a slack matrix to
1. This reduces the computational time of calculating the slack ideal, for
example.

This function automates the selection of a spanning forest in the bipartite
graph corresponding to S and sets the associated variables to 1.

+-----------------------------------------------------------------------------+
|i1 : V = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};                                   |
+-----------------------------------------------------------------------------+
|i2 : X = symbolicSlackMatrix V                                               |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}                                             |
|                                                                             |
|o2 = | 0   x_0 0   x_1 |                                                     |
|     | x_2 0   0   x_3 |                                                     |
|     | 0   x_4 x_5 0   |                                                     |
|     | x_6 0   x_7 0   |                                                     |
|                                                                             |
|                        4                 4                                  |
|o2 : Matrix (QQ[x ..x ])  <-- (QQ[x ..x ])                                   |
|                 0   7             0   7                                     |
+-----------------------------------------------------------------------------+
|i3 : (Y, F) = setOnesForest X                                                |
|                                                                             |
|o3 = (| 0 1 0   1 |, Graph{"edges" => {{y , y }, {y , y }, {y , y }, {y ,    |
|      | 1 0 0   1 |                      1   4     3   4     0   5     2     |
|      | 0 1 1   0 |        "ring" => QQ[y ..y ]                              |
|      | 1 0 x_7 0 |                      0   7                               |
|                           "vertices" => {y , y , y , y , y , y , y , y }    |
|                                           0   1   2   3   4   5   6   7     |
|     ------------------------------------------------------------------------|
|     y }, {y , y }, {y , y }, {y , y }}})                                    |
|      5     2   6     0   7     1   7                                        |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * graphFromSlackMatrix -- creates the
    vertex-edge incidence matrix for the bipartite non-incidence graph with
    adjacency matrix the given slack matrix
  * slackIdeal -- computes the slack ideal
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use setOnesForest:
==========================

  * "setOnesForest(Matrix)"

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

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

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

The source of this document is in SlackIdeals.m2:2211:0.

slackFromGaleCircuits -- computes the slack matrix of a polytope from a Gale transform of the polytope
******************************************************************************************************

  * Usage:
        M = slackFromGaleCircuits(G, Tolerance => 12)
        M = slackFromGaleCircuits G
  * Inputs:
      * G, a matrix (Macaulay2Doc), matrix of the form matrix(RR,
        {...}) whose columns are the vectors of a Gale transform
  * Optional inputs (Macaulay2Doc),:
      * Tolerance,
        => ..., default value 14, specifies the tolerance to compute the
        slack matrix of a polytope from a Gale transform of a polytope
  * Outputs:
      * SP, a matrix (Macaulay2Doc), the slack matrix of the
        polytope whose Gale transform is G

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

This function computes the slack matrix of a polytope starting from a matrix
whose columns correspond to the vertices of a Gale transform of the polytope.
The second argument Tolerance, which is optional, is a positive integer that
expresses the tolerance used in the computations, i.e. if an entry of a matrix
is less than 10^(-Tolerance), then it will be treated as zero. The default
value for the tolerance is 14.

+-----------------------------------------------------------------------------+
|i1 : G = matrix(RR, {{0, 1, -1, 0, -1, 1}, {1, 0, -1, -1, 0, 1}});           |
|                                                                             |
|                2         6                                                  |
|o1 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
+-----------------------------------------------------------------------------+
|i2 : M = slackFromGaleCircuits G                                             |
|-- warning: experimental computation over inexact field begun, results not   |
|                                                                             |
|o2 = | 1 0 0 1 0 |                                                           |
|     | 0 1 0 1 0 |                                                           |
|     | 0 0 1 1 0 |                                                           |
|     | 1 0 0 0 1 |                                                           |
|     | 0 1 0 0 1 |                                                           |
|     | 0 0 1 0 1 |                                                           |
|                                                                             |
|                6         5                                                  |
|o2 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|reliable                                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i3 : G = matrix(RR, {{1, 1, -1, -1, 0, 0}, {1, 1, 0, 0, -1, -1}});           |
|                                                                             |
|                2         6                                                  |
|o3 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
+-----------------------------------------------------------------------------+
|i4 : M = slackFromGaleCircuits G                                             |
|-- warning: experimental computation over inexact field begun, results not   |
|                                                                             |
|o4 = | 1 0 1 0 1 0 1 0 |                                                     |
|     | 0 1 0 1 0 1 0 1 |                                                     |
|     | 1 1 0 0 1 1 0 0 |                                                     |
|     | 0 0 1 1 0 0 1 1 |                                                     |
|     | 1 1 1 1 0 0 0 0 |                                                     |
|     | 0 0 0 0 1 1 1 1 |                                                     |
|                                                                             |
|                6         8                                                  |
|o4 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|reliable                                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i5 : G = matrix(RR, {{1, 0, 1, 0, 2, -2, -2}, {0, 1, 0, 1, 2, -2, -2}});     |
|                                                                             |
|                2         7                                                  |
|o5 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
+-----------------------------------------------------------------------------+
|i6 : M = slackFromGaleCircuits G                                             |
|-- warning: experimental computation over inexact field begun, results not   |
|                                                                             |
|o6 = | 0 0 2 0 2 0 2 0 2 0 |                                                 |
|     | 0 0 2 2 0 0 2 2 0 0 |                                                 |
|     | 0 0 0 2 0 2 0 2 0 2 |                                                 |
|     | 0 0 0 0 2 2 0 0 2 2 |                                                 |
|     | 1 1 0 0 0 0 0 0 0 0 |                                                 |
|     | 1 0 1 1 1 1 0 0 0 0 |                                                 |
|     | 0 1 0 0 0 0 1 1 1 1 |                                                 |
|                                                                             |
|                7         10                                                 |
|o6 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|reliable                                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i7 : G = matrix(RR, {{1, -4, 6, -4, 1, 0, 0}, {4, -15, 20, -10, 0, 1, 0},    |
|                                                                             |
|                3         7                                                  |
|o7 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|{10, -36, 45, -20, 0, 0, 1}});                                               |
+-----------------------------------------------------------------------------+
|i8 : M = slackFromGaleCircuits G                                             |
|-- warning: experimental computation over inexact field begun, results not   |
|                                                                             |
|o8 = | 20 0    36 6       1  0   0  0       0        0   |                   |
|     | 10 2.5  15 1.66667 0  0   1  .166667 .0277778 0   |                   |
|     | 4  3    4  0       0  .4  1  .111111 0        0   |                   |
|     | 1  2.25 0  0       .5 .9  .5 0       0        .05 |                   |
|     | 0  1    0  .666667 1  1.2 0  0       .111111  .2  |                   |
|     | 0  0    1  1       1  1   0  .277778 .416667  .5  |                   |
|     | 0  0    0  0       0  0   1  1       1        1   |                   |
|                                                                             |
|                7         10                                                 |
|o8 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|reliable                                                                     |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i9 : G = matrix(RR, {{-sqrt(10+2*sqrt(5))*(sqrt(5)+1)/(4*(sqrt(5)-1)),       |
|                                                                             |
|                3         12                                                 |
|o9 : Matrix RR    <-- RR                                                     |
|              53        53                                                   |
|-----------------------------------------------------------------------------|
|sqrt(10+2*sqrt(5))*(sqrt(5)+1)/(4*(sqrt(5)-1)),                              |
|-----------------------------------------------------------------------------|
|-4*sqrt(5)/(sqrt(10+2*sqrt(5))*(sqrt(5)+1)+(sqrt(5)-5)*sqrt(10-2*sqrt(5))),  |
|-----------------------------------------------------------------------------|
|4*sqrt(5)/(sqrt(10+2*sqrt(5))*(sqrt(5)+1)+(sqrt(5)-5)*sqrt(10-2*sqrt(5))),   |
|-----------------------------------------------------------------------------|
|-sqrt(10-2*sqrt(5))/4, sqrt(10-2*sqrt(5))/4, -sqrt(10+2*sqrt(5))/4,          |
|-----------------------------------------------------------------------------|
|sqrt(10+2*sqrt(5))/4, -sqrt(10-2*sqrt(5))/4, sqrt(10+2*sqrt(5))/4,           |
|-----------------------------------------------------------------------------|
|-sqrt(10+2*sqrt(5))/4, 0}, {(sqrt(5)+1)/4, (sqrt(5)+1)/4,                    |
|-----------------------------------------------------------------------------|
|(-5-sqrt(5))/(6*sqrt(5)-10), (-5-sqrt(5))/(6*sqrt(5)-10), (sqrt(5)+1)/4,     |
|-----------------------------------------------------------------------------|
|(sqrt(5)+1)/4, -(sqrt(5)-1)/4, -(sqrt(5)-1)/4, -(sqrt(5)+1)/4, (sqrt(5)-1)/4,|
|-----------------------------------------------------------------------------|
|(sqrt(5)-1)/4, 0}, {1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1}});               |
+-----------------------------------------------------------------------------+
|i10 : M = slackFromGaleCircuits G                                            |
|-- warning: experimental computation over inexact field begun, results not re|
|                                                                             |
|o10 = | 0 0 0 .381966 0       .618034 0       0       0       0       0      |
|      | 0 0 0 .618034 .381966 0       0       .618034 0       0       0      |
|      | 0 0 0 0       0       0       .381966 .381966 0       0       .276393|
|      | 0 0 0 0       0       .381966 0       0       .381966 .276393 0      |
|      | 0 0 0 0       .618034 0       .618034 0       0       .723607 0      |
|      | 1 0 0 0       0       0       0       0       .618034 0       .723607|
|      | 0 1 0 0       0       0       0       0       0       0       0      |
|      | 0 0 1 0       0       0       0       0       0       0       0      |
|      | 1 0 0 1       1       0       0       0       0       0       0      |
|      | 0 1 0 0       0       1       1       0       0       0       0      |
|      | 0 0 1 0       0       0       0       1       1       0       0      |
|      | 0 0 0 0       0       0       0       0       0       1       1      |
|      -----------------------------------------------------------------------|
|      0       .276393 .381966 .236068 .381966 0       .618034 0       .236068|
|      .276393 0       .236068 0       0       0       0       0       .381966|
|      0       0       .381966 .381966 .236068 0       0       0       0      |
|      0       0       0       0       0       .381966 0       0       .381966|
|      0       0       0       0       0       1.61803 0       1.61803 0      |
|      0       0       0       .381966 0       0       0       0       0      |
|      .723607 0       0       0       0       0       0       0       0      |
|      0       .723607 0       0       .381966 0       1       1       0      |
|      0       0       0       0       0       1       .618034 1.61803 0      |
|      0       0       1       1       1       1       1       1       0      |
|      0       0       0       0       0       0       0       0       1      |
|      1       1       0       0       0       0       0       0       0      |
|      -----------------------------------------------------------------------|
|      0       0       0 0       0       .276393 .447214 0       .276393      |
|      .236068 .381966 1 0       0       .447214 .276393 .276393 0            |
|      0       0       0 0       1       .276393 0       .276393 0            |
|      .381966 .236068 0 .618034 0       0       .276393 0       .276393      |
|      .381966 0       0 1       0       0       0       .447214 0            |
|      0       0       0 0       1.61803 0       0       0       .447214      |
|      0       .381966 1 0       0       0       0       0       0            |
|      0       0       0 0       0       0       0       0       0            |
|      0       0       1 0       0       0       0       0       0            |
|      0       0       0 .618034 1.61803 0       0       0       0            |
|      1       1       1 1       1       0       0       0       0            |
|      0       0       0 0       0       1       1       1       1            |
|      -----------------------------------------------------------------------|
|      0       0       0       0       0       |                              |
|      0       0       0       0       0       |                              |
|      0       .105573 0       0       0       |                              |
|      .105573 0       0       0       0       |                              |
|      0       .447214 .276393 0       .723607 |                              |
|      .447214 0       0       .276393 0       |                              |
|      .447214 0       .276393 .447214 0       |                              |
|      0       .447214 .447214 .276393 .723607 |                              |
|      0       0       0       0       .447214 |                              |
|      0       0       0       0       0       |                              |
|      0       0       0       0       0       |                              |
|      1       1       1       1       1       |                              |
|                                                                             |
|                 12         34                                               |
|o10 : Matrix RR     <-- RR                                                   |
|               53         53                                                 |
|-----------------------------------------------------------------------------|
|liable                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * slackMatrix -- computes the slack matrix of a given
    realization
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use slackFromGaleCircuits:
==================================

  * "slackFromGaleCircuits(Matrix)"

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

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

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

The source of this document is in SlackIdeals.m2:1723:0.

slackFromGaleCircuits(...,Tolerance=>...) -- specifies the tolerance to compute the slack matrix of a polytope from a Gale transform of a polytope
**************************************************************************************************************************************************

  * Usage:
        slackFromGaleCircuits(..., Tolerance => 12)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Tolerance:
=================================================

  * slackFromGaleCircuits(...,Tolerance=>...)
    -- specifies
    the tolerance to compute the slack matrix of a polytope from a Gale
    transform of a polytope

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

  * Default value: 14
  * Function: slackFromGaleCircuits, -- computes
    the slack matrix of a polytope from a Gale transform of the polytope
  * Option key: Tolerance, -- choose the tolerance to
    approximate computations over the field RR
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3085:0.

slackFromGalePlucker -- fill the slack matrix with Plücker coordinates of the Gale transform
********************************************************************************************

  * Usage:
        fillPl = slackFromGalePlucker(B, G)
        fillPl = slackFromGalePlucker(B, MG)
  * Inputs:
      * B, a list (Macaulay2Doc), set of hyperplane spanning set
        indices
      * G, a list (Macaulay2Doc), list of Gale vectors of a
        polytope
      * MG, a matrix (Macaulay2Doc), matrix of Gale vectors of a
        polytope
  * Outputs:
      * fillPl, a matrix (Macaulay2Doc), slack matrix filled with
        Plücker coordinates

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

Given a set of vectors of a Gale transform or a matrix whose columns form a
Gale transform of a polytope, it fills the slack matrix of the polytope with
Plücker coordinates of the Gale transform.

+-----------------------------------------------------------------+
|i1 : G = {{0, 1}, {1, 0}, {-1, -1}, {0, -1}, {-1, 0}, {1, 1}};   |
+-----------------------------------------------------------------+
|i2 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};|
+-----------------------------------------------------------------+
|i3 : slackFromGalePlucker(B, G)                                  |
|                                                                 |
|o3 = | 1 0  0 1 0  |                                             |
|     | 0 -1 0 1 0  |                                             |
|     | 0 0  1 1 0  |                                             |
|     | 1 0  0 0 -1 |                                             |
|     | 0 -1 0 0 -1 |                                             |
|     | 0 0  1 0 -1 |                                             |
|                                                                 |
|              6       5                                          |
|o3 : Matrix ZZ  <-- ZZ                                           |
+-----------------------------------------------------------------+
+-------------------------------------------------------------------+
|i4 : MG = matrix(RR, {{0, 1, -1, 0, -1, 1}, {1, 0, -1, -1, 0, 1}});|
|                                                                   |
|                2         6                                        |
|o4 : Matrix RR    <-- RR                                           |
|              53        53                                         |
+-------------------------------------------------------------------+
|i5 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};  |
+-------------------------------------------------------------------+
|i6 : slackFromGalePlucker(B, MG)                                   |
|                                                                   |
|o6 = | 1 0  0 1 0  |                                               |
|     | 0 -1 0 1 0  |                                               |
|     | 0 0  1 1 0  |                                               |
|     | 1 0  0 0 -1 |                                               |
|     | 0 -1 0 0 -1 |                                               |
|     | 0 0  1 0 -1 |                                               |
|                                                                   |
|                6         5                                        |
|o6 : Matrix RR    <-- RR                                           |
|              53        53                                         |
+-------------------------------------------------------------------+

Caveat
======

Does not check if B actually spans for given V, does not check orientation of
simplices in B, so that the resulting slack matrix may differ by signs of each
column.

See also
========

  * getFacetBases -- get a list of d-spanning elements
    for each facet
  * slackFromPlucker -- fill the slack matrix of a
    given polytope, cone or matroid with Plücker coordinates

Ways to use slackFromGalePlucker:
=================================

  * "slackFromGalePlucker(List,List)"
  * "slackFromGalePlucker(List,Matrix)"

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

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

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

The source of this document is in SlackIdeals.m2:1680:0.

slackFromPlucker -- fill the slack matrix of a given polytope, cone or matroid with Plücker coordinates
*******************************************************************************************************

  * Usage:
        fillPl = slackFromPlucker(V, B)
        fillPl = slackFromPlucker V
        fillPl = slackFromPlucker P
        fillPl = slackFromPlucker M
  * Inputs:
      * V, a list (Macaulay2Doc), list of coordinates for polytope
        vertices, cone generators, or matroid vectors
      * B, a list (Macaulay2Doc), set of hyperplane spanning set
        indices
      * P, a convex polyhedron (Polyhedra), a polytope
      * M, a matroid (Matroids), a matroid
  * Optional inputs (Macaulay2Doc),:
      * Object, =>
        ..., default value "polytope", specify combinatorial object
  * Outputs:
      * fillPl, a matrix (Macaulay2Doc), slack matrix filled with
        Plücker coordinates

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

Given a slack matrix or a list of vertices of d-polytope or a rank d+1 matroid,
or (d+1)-cone generators, it fills the corresponding slack matrix with Plücker
coordinates.

+----------------------------------------------------------------------------+
|i1 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}};|
+----------------------------------------------------------------------------+
|i2 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};           |
+----------------------------------------------------------------------------+
|i3 : fillPl = slackFromPlucker(V, B)                                        |
|                                                                            |
|o3 = | -1 0 0  -1 0 |                                                       |
|     | 0  1 0  -1 0 |                                                       |
|     | 0  0 -1 0  0 |                                                       |
|     | -1 0 0  0  1 |                                                       |
|     | 0  1 0  0  1 |                                                       |
|     | 1  1 -1 0  0 |                                                       |
|                                                                            |
|              6       5                                                     |
|o3 : Matrix ZZ  <-- ZZ                                                      |
+----------------------------------------------------------------------------+
+----------------------------------------------------------------------------+
|i4 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}};|
+----------------------------------------------------------------------------+
|i5 : fillPl = slackFromPlucker V                                            |
|                                                                            |
|Input has been reordered to                                                 |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}, {0, 0, 1}, {1, 0, 1}}          |
|                                                                            |
|o5 = | 0 -1 0  0 1 |                                                        |
|     | 1 0  0  0 1 |                                                        |
|     | 0 -1 -1 0 0 |                                                        |
|     | 1 0  -1 0 0 |                                                        |
|     | 0 -1 0  1 0 |                                                        |
|     | 1 0  0  1 0 |                                                        |
|                                                                            |
|              6       5                                                     |
|o5 : Matrix QQ  <-- QQ                                                      |
+----------------------------------------------------------------------------+

Caveat
======

Does not check if B actually spans for given V, does not check orientation of
simplices in B, so that the resulting slack matrix may differ by signs of each
column.

See also
========

  * getFacetBases -- get a list of d-spanning elements
    for each facet

Ways to use slackFromPlucker:
=============================

  * "slackFromPlucker(List)"
  * "slackFromPlucker(List,List)"
  * "slackFromPlucker(Matroid)"
  * "slackFromPlucker(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:1641:0.

slackFromPlucker(...,Object=>...) -- specify combinatorial object
*****************************************************************

  * Usage:
        slackFromPlucker(..., Object => "cone")
        slackFromPlucker(..., Object => "abstractPolytope")
        slackFromPlucker(..., Object => "polytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: slackFromPlucker, -- fill the slack
    matrix of a given polytope, cone or matroid with Plücker coordinates
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2621:0.

slackIdeal -- computes the slack ideal
**************************************

  * Usage:
        I = slackIdeal(d, V)
        I = slackIdeal M
        I = slackIdeal P
        I = slackIdeal C
        I = slackIdeal V
        I = slackIdeal(d, S)
        I = slackIdeal S
  * Inputs:
      * d, an integer (Macaulay2Doc), the dimension of the polytope
        or 1 less than the rank of the matroid
      * V, a list (Macaulay2Doc), a list of vertices of a polytope,
        the vectors of a linear matroid, or facet sets of an abstract polytope
      * M, a matroid (Matroids), a matroid
      * P, a convex polyhedron (Polyhedra), a polytope
      * C, a convex rational cone (Polyhedra), a cone
      * S, a matrix (Macaulay2Doc), a (symbolic) slack matrix
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ..., default
        value QQ, specifies the coefficient ring of the underlying ring of the
        ideal
      * Object, => ...,
        default value "polytope", specify combinatorial object
      * Saturate, =>
        ..., default value "all", specifies saturation strategy to be used
      * Strategy, =>
        ..., default value Eliminate, specifies saturation strategy to be used
      * Vars, => ...,
        default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * I, an ideal (Macaulay2Doc), the slack ideal - the
        saturated ideal of (d+2)-minors of the symbolic slack matrix

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

The slack ideal of a d-polytope or rank d+1 matroid is the ideal of
(d+2)-minors of its symbolic slack matrix, saturated by the product of the
variables in the matrix.

+------------------------------------------+
|i1 : V = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};|
+------------------------------------------+
|i2 : I = slackIdeal V                     |
|                                          |
|Order of vertices is                      |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}          |
|                                          |
|o2 = ideal(x x x x  - x x x x )           |
|            0 3 5 6    1 2 4 7            |
|                                          |
|o2 : Ideal of QQ[x ..x ]                  |
|                  0   7                   |
+------------------------------------------+

If a list of points is given it can be treated as the vertices of a polytope,
the ground set of a matroid or the facets of an abstract polytope by specifying
the option Object. The default is as a polytope.

+-----------------------------------------------------------------------------+
|i3 : V = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};                                   |
+-----------------------------------------------------------------------------+
|i4 : IP = slackIdeal V                                                       |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}                                             |
|                                                                             |
|o4 = ideal(x x x x  - x x x x )                                              |
|            0 3 5 6    1 2 4 7                                               |
|                                                                             |
|o4 : Ideal of QQ[x ..x ]                                                     |
|                  0   7                                                      |
+-----------------------------------------------------------------------------+
|i5 : IM = slackIdeal(V, Object => "matroid")                                 |
|                                                                             |
|o5 = ideal (x x x   + x x x  , x x x  + x x x  , x x x  + x x x  , x x x  +  |
|             4 8 10    5 7 11   1 8 9    2 6 11   0 5 9    2 3 10   0 4 6    |
|     ------------------------------------------------------------------------|
|     x x x , x x x x   - x x x x  , x x x x  - x x x x  , x x x x  -         |
|      1 3 7   1 3 8 10    0 5 6 11   0 4 8 9    2 3 7 11   1 5 7 9           |
|     ------------------------------------------------------------------------|
|     x x x x  )                                                              |
|      2 4 6 10                                                               |
|                                                                             |
|o5 : Ideal of QQ[x ..x  ]                                                    |
|                  0   11                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * slackMatrix -- computes the slack matrix of a given
    realization
  * symbolicSlackMatrix -- computes the symbolic
    slack matrix

Ways to use slackIdeal:
=======================

  * "slackIdeal(Cone)"
  * "slackIdeal(List)"
  * "slackIdeal(Matrix)"
  * "slackIdeal(Matroid)"
  * "slackIdeal(Polyhedron)"
  * "slackIdeal(ZZ,List)"
  * "slackIdeal(ZZ,Matrix)"

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

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

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

The source of this document is in SlackIdeals.m2:1924:0.

slackIdeal(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
**********************************************************************************************************

  * Usage:
        slackIdeal(..., CoefficientRing => QQ)
        slackIdeal(..., CoefficientRing => ZZ/7)
        slackIdeal(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: slackIdeal, -- computes the slack ideal
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2856:0.

slackIdeal(...,Object=>...) -- specify combinatorial object
***********************************************************

  * Usage:
        slackIdeal(..., Object => "polytope")
        slackIdeal(..., Object => "matroid")
        slackIdeal(..., Object => "abstractPolytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: slackIdeal, -- computes the slack ideal
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2531:0.

slackIdeal(...,Saturate=>...) -- specifies saturation strategy to be used
*************************************************************************

  * Usage:
        slackIdeal(..., Saturate => "all")
        slackIdeal(..., Saturate => "each")

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

Functions with optional argument named Saturate:
================================================

  * cycleIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * graphicIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * rehomogenizeIdeal(...,Saturate=>...)
    -- specifies
    saturation strategy to be used
  * slackIdeal(...,Saturate=>...)
    -- specifies saturation
    strategy to be used

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

  * Default value: all
  * Function: slackIdeal, -- computes the slack ideal
  * Option key: Saturate, -- choose whether to saturate with
    respect to the product of all variables at the same time or variable by
    variable.
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2769:0.

slackIdeal(...,Strategy=>...) -- specifies saturation strategy to be used
*************************************************************************

  * Usage:
        slackIdeal(..., Strategy => Iterate)
        slackIdeal(..., Strategy => Bayer)
        slackIdeal(..., Strategy => Linear)
        slackIdeal(..., Strategy => Eliminate)

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument

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
  * cycleIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * 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)
  * "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
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * graphicIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * grassmannSectionIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "greeneKleitmanPartition(...,Strategy=>...)" -- see
    greeneKleitmanPartition (Posets), -- computes the
    Greene-Kleitman partition of a poset
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * "hasMinor(...,Strategy=>...)" -- see hasMinor (Matroids), --
    whether a matroid has a given minor
  * hermite(...,Strategy=>...) (missing documentation)
  * "hibiRing(...,Strategy=>...)" -- see hibiRing (Posets), --
    produces the Hibi ring of a poset
  * "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
  * "isIsomorphic(...,Strategy=>...)" -- see isIsomorphic (Isomorphism),
    -- probabilistic test for isomorphism of modules
  * isomorphism(...,Strategy=>...) (missing documentation)
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * "lcmLattice(...,Strategy=>...)" -- see lcmLattice (Posets),
    -- generates the lattice of lcms in an ideal
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * "pPartitionRing(...,Strategy=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * "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)
  * rehomogenizeIdeal(...,Strategy=>...)
    -- specifies
    saturation strategy to be used
  * "resolutionMap(...,Strategy=>...)" -- see resolutionMap (Complexes),
    -- map from a free resolution to the given
    complex
  * saturate(...,Strategy=>...) (missing documentation)
  * slackIdeal(...,Strategy=>...)
    -- specifies saturation
    strategy to be used
  * "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
  * "transitiveOrientation(...,Strategy=>...)" -- see
    transitiveOrientation (Posets), -- generates a poset
    whose comparability graph is the given graph

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

  * Default value: Eliminate (Macaulay2Doc),
  * Function: slackIdeal, -- computes the slack ideal
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2678:0.

slackIdeal(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
******************************************************************************************************

  * Usage:
        slackIdeal(..., Vars => {a..r})
        slackIdeal(..., Vars => {y_1..y_6})
        slackIdeal(..., Vars => {A, B, S, T})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: slackIdeal, -- computes the slack ideal
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2990:0.

slackMatrix -- computes the slack matrix of a given realization
***************************************************************

  * Usage:
        S = slackMatrix V
        S = slackMatrix M
        S = slackMatrix P
        S = slackMatrix C
  * Inputs:
      * V, a list (Macaulay2Doc), a list of vertices of a polytope,
        or the vectors of a linear matroid
      * M, a matroid (Matroids), a matroid
      * P, a convex polyhedron (Polyhedra), a polytope
      * C, a convex rational cone (Polyhedra), a cone
  * Optional inputs (Macaulay2Doc),:
      * Object, => ...,
        default value "polytope", specify combinatorial object
  * Outputs:
      * S, a matrix (Macaulay2Doc), a slack matrix of the
        realization

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

A slack matrix depends on the given representation. Its rows are indexed by
vertices/ground set elements and its columns are indexed by facets/hyperplanes.
The (i, j)-entry is the j-th inequality evaluated on element i.

+---------------------------------------------+
|i1 : V = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};   |
+---------------------------------------------+
|i2 : SP = slackMatrix V                      |
|                                             |
|Order of vertices is                         |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}             |
|                                             |
|o2 = | 0 1 0 1 |                             |
|     | 1 0 0 1 |                             |
|     | 0 1 1 0 |                             |
|     | 1 0 1 0 |                             |
|                                             |
|              4       4                      |
|o2 : Matrix QQ  <-- QQ                       |
+---------------------------------------------+
|i3 : SM = slackMatrix(V, Object => "matroid")|
|                                             |
|o3 = | -1 -1 0 -1 0  0  |                    |
|     | -1 0  1 0  1  0  |                    |
|     | 0  1  1 0  0  -1 |                    |
|     | 0  0  0 -1 -1 -1 |                    |
|                                             |
|              4       6                      |
|o3 : Matrix ZZ  <-- ZZ                       |
+---------------------------------------------+
+----------------------------------------------------------+
|i4 : C = posHull(matrix{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}});|
+----------------------------------------------------------+
|i5 : S = slackMatrix C                                    |
|                                                          |
|Order of rays is                                          |
|{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}                         |
|                                                          |
|o5 = | 1 0 0 |                                            |
|     | 0 1 0 |                                            |
|     | 0 0 1 |                                            |
|                                                          |
|              3       3                                   |
|o5 : Matrix ZZ  <-- ZZ                                    |
+----------------------------------------------------------+

Caveat
======

When giving a Matroid as input, the ground set must be a set of vectors giving
a representation of the matroid.

See also
========

  * symbolicSlackMatrix -- computes the symbolic
    slack matrix
  * Object -- select the combinatorial object which the input
    should be interpreted as

Ways to use slackMatrix:
========================

  * "slackMatrix(Cone)"
  * "slackMatrix(List)"
  * "slackMatrix(Matroid)"
  * "slackMatrix(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:1552:0.

slackMatrix(...,Object=>...) -- specify combinatorial object
************************************************************

  * Usage:
        slackMatrix(..., Object => "polytope")
        slackMatrix(..., Object => "matroid")

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

Indicates whether an input list should be treated as the vertices of a polytope
or the ground set of a matroid.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: slackMatrix, -- computes the slack matrix of a
    given realization
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2501:0.

specificSlackMatrix -- creates built-in slack matrices of some polytopes and matroids
*************************************************************************************

  * Usage:
        specificSlackMatrix name
  * Inputs:
      * name, a string (Macaulay2Doc), the name of the polytope
        or of matroids
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns a slack matrix of one of the named polytopes and matroids below.

+-----------------------------------------------------------------------------+
|i1 : peek specificSlackMatrix "perles1"                                      |
|(dimension, 8)                                                               |
|                                                                             |
|o1 = Matrix{cache => CacheTable{}                                            |
|            RawMatrix => 0 0 0 .381966 .618034 .276393 0       0             |
|                         0 0 0 .618034 0       0       .618034 .381966       |
|                         0 0 0 0       0       0       .381966 0             |
|                         0 0 0 0       .381966 0       0       0             |
|                         0 0 0 0       0       0       0       .618034       |
|                         1 0 0 0       0       0       0       0             |
|                         0 1 0 0       0       0       0       0             |
|                         0 0 1 0       0       .723607 0       0             |
|                         1 0 0 1       0       0       0       1             |
|                         0 1 0 0       1       0       0       0             |
|                         0 0 1 0       0       0       1       0             |
|                         0 0 0 0       0       1       0       0             |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          12                                                 |
|            target => RR                                                     |
|                        53                                                   |
|                          34                                                 |
|            source => RR                                                     |
|                        53                                                   |
|-----------------------------------------------------------------------------|
|                                                                             |
|0       0       0       0       0       .381966 .276393 .236068 .447214      |
|.276393 0       0       0       0       .236068 .447214 .381966 .276393      |
|0       .381966 .276393 0       0       .381966 .276393 0       0            |
|0       0       0       .276393 .381966 0       0       .381966 .276393      |
|0       .618034 0       .723607 0       0       0       0       0            |
|0       0       .723607 0       .618034 0       0       0       0            |
|.723607 0       0       0       0       0       0       0       0            |
|0       0       0       0       0       0       0       0       0            |
|0       0       0       0       0       0       0       0       0            |
|0       1       0       0       0       1       0       0       0            |
|0       0       0       0       1       0       0       1       0            |
|1       0       1       1       0       0       1       0       1            |
|-----------------------------------------------------------------------------|
|                                                                             |
|.236068 .381966 .276393 .618034 0       0       0       0 0       0          |
|0       0       0       0       .276393 .236068 .381966 1 0       0          |
|.381966 .236068 0       0       .276393 0       0       0 .105573 1          |
|0       0       .276393 0       0       .381966 .236068 0 0       0          |
|0       0       0       0       .447214 .381966 0       0 .447214 0          |
|.381966 0       .447214 0       0       0       0       0 0       1.61803    |
|0       0       0       0       0       0       .381966 1 0       0          |
|0       .381966 0       1       0       0       0       0 .447214 0          |
|0       0       0       .618034 0       0       0       1 0       0          |
|1       1       0       1       0       0       0       0 0       1.61803    |
|0       0       0       0       0       1       1       1 0       1          |
|0       0       1       0       1       0       0       0 1       0          |
|-----------------------------------------------------------------------------|
|                                                        }                    |
|0       0       0       0       0       0       0                            |
|0       0       0       0       0       0       0                            |
|0       0       0       0       0       0       0                            |
|.381966 .618034 .105573 0       0       0       0                            |
|1.61803 1       0       .276393 1.61803 .723607 0                            |
|0       0       .447214 0       0       0       .276393                      |
|0       0       .447214 .276393 0       0       .447214                      |
|0       0       0       .447214 1       .723607 .276393                      |
|1       0       0       0       1.61803 .447214 0                            |
|1       .618034 0       0       1       0       0                            |
|0       1       0       0       0       0       0                            |
|0       0       1       1       0       1       1                            |
+-----------------------------------------------------------------------------+
|i2 : peek specificSlackMatrix "perles2"                                      |
|(dimension, 8)                                                               |
|                                                                             |
|o2 = Matrix{cache => CacheTable{}                                            |
|            RawMatrix => 8.01592 12.3895 9.98459 0      0       0            |
|                         0       2.61201 1.48343 0      0       5.88981      |
|                         .776541 .320214 .93418  0      .972667 0            |
|                         0       0       3.12332 5.5983 0       0            |
|                         0       0       0       0      5.43926 12.0634      |
|                         0       0       0       0      0       0            |
|                         0       0       0       0      0       0            |
|                         0       0       0       0      0       0            |
|                         0       0       0       0      0       0            |
|                         1.51133 6.2131  0       0      3.09631 0            |
|                         0       0       0       0      0       0            |
|                         1.6962  0       0       6.4017 2.49176 0            |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          12                                                 |
|            target => RR                                                     |
|                        53                                                   |
|                          30                                                 |
|            source => RR                                                     |
|                        53                                                   |
|-----------------------------------------------------------------------------|
|                                                                             |
|10.0556  0       0       0      0       0       0       0       8.0552       |
|1.07692  0       .193124 0      4.22353 0       0       0       0            |
|0        0       0       1.3495 3.31745 .293671 1.42587 1.77962 1.23085      |
|.786008  0       2.51556 0      4.62053 4.9376  0       0       0            |
|0        0       0       0      0       0       10.2391 10.1162 0            |
|.0815211 12.8553 2.10439 0      0       0       0       0       0            |
|0        0       7.18693 6.3903 10.5164 13.8854 10.9342 0       0            |
|0        0       0       0      0       9.19894 5.35682 9.20659 2.71395      |
|0        0       0       0      0       0       0       0       0            |
|0        20.5617 0       4.2602 0       0       0       0       0            |
|0        0       0       0      0       0       0       0       0            |
|0        0       0       0      0       0       0       4.35916 0            |
|-----------------------------------------------------------------------------|
|                                                                             |
|0       0       0       0       0       0       0       0       0            |
|0       0       0       0       1.58198 0       0       1.77879 0            |
|1.06068 0       3.05166 1.28138 0       7.3186  .597798 1.3509  .954094      |
|0       3.24017 0       0       2.06082 0       0       0       0            |
|5.54237 0       0       0       0       0       0       0       0            |
|1.70477 2.77375 0       0       .158168 24.1704 0       0       0            |
|0       0       0       5.3515  0       0       0       0       4.92949      |
|3.69218 5.98608 0       5.33146 0       37.8997 5.1117  0       5.65514      |
|0       0       18.4504 6.72194 8.19903 84.1558 7.90648 8.87031 0            |
|0       0       9.11228 0       0       0       0       0       0            |
|0       0       0       0       0       0       0       0       9.6277       |
|0       0       6.81618 0       0       0       4.32106 0       0            |
|-----------------------------------------------------------------------------|
|                                                }                            |
|6.08418 0       0       0       0       0                                    |
|.979913 2.30656 1.3969  0       0       1.51872                              |
|.985993 1.44624 0       3.7944  .306002 1.14899                              |
|0       0       1.79646 0       0       0                                    |
|0       0       0       0       0       0                                    |
|0       0       1.78409 5.578   0       1.76326                              |
|0       10.4479 0       0       0       0                                    |
|0       0       0       13.2252 0       0                                    |
|0       0       0       0       0       0                                    |
|0       0       0       0       0       0                                    |
|3.94992 11.1553 7.02255 24.8246 11.3839 7.56903                              |
|0       0       0       0       .310109 0                                    |
+-----------------------------------------------------------------------------+
|i3 : peek specificSlackMatrix "barnette"                                     |
|(dimension, 4)                                                               |
|                                                                             |
|o3 = Matrix{cache => CacheTable{}      }                                     |
|            RawMatrix => 1 0 0 0 1 1 0                                       |
|                         1 0 0 0 0 1 1                                       |
|                         1 0 0 1 0 0 1                                       |
|                         1 0 0 1 1 0 0                                       |
|                         1 0 1 0 0 0 0                                       |
|                         0 1 0 0 1 1 0                                       |
|                         0 1 0 0 0 1 1                                       |
|                         0 1 0 1 0 0 1                                       |
|                         0 1 0 1 1 0 0                                       |
|                         0 1 1 0 0 0 0                                       |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          7                                                  |
|            source => RR                                                     |
|                        53                                                   |
|                          10                                                 |
|            target => RR                                                     |
|                        53                                                   |
+-----------------------------------------------------------------------------+
|i4 : peek specificSlackMatrix "toric-non-graphic"                            |
|(dimension, 5)                                                               |
|                                                                             |
|o4 = Matrix{cache => CacheTable{}        }                                   |
|            RawMatrix => 0 1 1 0 0 0 0 1                                     |
|                         1 1 1 0 0 0 0 0                                     |
|                         0 0 1 1 0 0 0 0                                     |
|                         0 1 0 0 0 1 0 0                                     |
|                         1 0 1 0 0 0 1 0                                     |
|                         0 0 1 0 0 0 1 1                                     |
|                         0 0 0 0 0 1 1 0                                     |
|                         1 1 0 0 1 0 0 0                                     |
|                         0 1 0 0 1 0 0 1                                     |
|                         0 0 0 1 1 0 0 0                                     |
|                         0 0 0 0 1 0 1 1                                     |
|                         1 0 0 0 1 0 1 0                                     |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          8                                                  |
|            source => RR                                                     |
|                        53                                                   |
|                          12                                                 |
|            target => RR                                                     |
|                        53                                                   |
+-----------------------------------------------------------------------------+
|i5 : peek specificSlackMatrix "pu-non-mcmullen"                              |
|(dimension, 5)                                                               |
|                                                                             |
|o5 = Matrix{cache => CacheTable{}            }                               |
|            RawMatrix => 0 0 1 0 0 0 1 1 0 0                                 |
|                         1 1 1 0 0 0 0 0 0 0                                 |
|                         0 0 0 1 1 0 1 0 0 0                                 |
|                         0 1 0 1 0 0 0 0 0 1                                 |
|                         0 1 1 1 0 0 0 0 1 0                                 |
|                         1 0 0 0 1 1 0 0 0 0                                 |
|                         0 0 1 0 0 1 0 1 1 0                                 |
|                         0 0 0 0 0 1 0 1 0 1                                 |
|                         0 0 0 1 1 1 0 0 1 0                                 |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          9                                                  |
|            target => RR                                                     |
|                        53                                                   |
|                          10                                                 |
|            source => RR                                                     |
|                        53                                                   |
+-----------------------------------------------------------------------------+
|i6 : peek specificSlackMatrix "fano-matroid"                                 |
|(dimension, 2)                                                               |
|                                                                             |
|o6 = Matrix{cache => CacheTable{}      }                                     |
|            RawMatrix => 1 0 1 0 0 1 1                                       |
|                         0 0 1 1 1 1 0                                       |
|                         0 1 1 0 1 0 1                                       |
|                         1 1 1 1 0 0 0                                       |
|                         1 0 0 1 1 0 1                                       |
|                         1 1 0 0 1 1 0                                       |
|                         0 1 0 1 0 1 1                                       |
|                                                                             |
|                       ZZ 7                                                  |
|            source => (--)                                                   |
|                        2                                                    |
|                       ZZ 7                                                  |
|            target => (--)                                                   |
|                        2                                                    |
|                    ZZ                                                       |
|            ring => --                                                       |
|                     2                                                       |
+-----------------------------------------------------------------------------+
|i7 : peek specificSlackMatrix "complex-matroid"                              |
|(dimension, 2)                                                               |
|                                                                             |
|o7 = Matrix{cache => CacheTable{}                                     }      |
|            RawMatrix => 0  a 1 1    0    1  0   a-1 -a+1 a    1 0           |
|                         -a 0 1 a    0    0  1   -1  1    -1   0 -a+1        |
|                         1  0 a 0    -a+1 a  0   -a  1    0    1 1           |
|                         1  a a 0    0    1  a-1 0   0    1    1 a           |
|                         a  0 0 -a+1 -a+1 a  -a  0   -a+1 a    1 0           |
|                         0  1 0 0    a    -a a   1   a-1  -a+1 0 a           |
|                         0  1 1 1    1    0  1   0   1    0    1 1           |
|                         a  1 0 -a+1 1    0  0   1   0    1    1 a           |
|                                                                             |
|                       QQ[a]                                                 |
|            ring => ----------                                               |
|                     2                                                       |
|                    a  - a + 1                                               |
|                      /   QQ[a]  \8                                          |
|            target => |----------|                                           |
|                      | 2        |                                           |
|                      \a  - a + 1/                                           |
|                      /   QQ[a]  \12                                         |
|            source => |----------|                                           |
|                      | 2        |                                           |
|                      \a  - a + 1/                                           |
+-----------------------------------------------------------------------------+
|i8 : peek specificSlackMatrix "nonfano-matroid"                              |
|(dimension, 2)                                                               |
|                                                                             |
|o8 = Matrix{cache => CacheTable{}                }                           |
|            RawMatrix => 1  0 1  0  0  1 1  1  1                             |
|                         0  0 1  1  -1 1 2  0  0                             |
|                         0  1 -1 0  1  0 -1 -1 1                             |
|                         -1 1 -1 1  0  0 0  -2 0                             |
|                         1  0 0  -1 1  0 -1 1  1                             |
|                         1  1 0  0  1  1 0  0  2                             |
|                         0  1 0  1  0  1 1  -1 1                             |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          7                                                  |
|            target => RR                                                     |
|                        53                                                   |
|                          9                                                  |
|            source => RR                                                     |
|                        53                                                   |
+-----------------------------------------------------------------------------+
|i9 : peek specificSlackMatrix "perles-matroid"                               |
|(dimension, 2)                                                               |
|                                                                             |
|o9 = Matrix{cache => CacheTable{}                                            |
|            RawMatrix => 0        1        -2.61803 .381966  0               |
|                         -4.23607 1        0        0        .381966         |
|                         1        .381966  1        0        .381966         |
|                         1        0        -.618034 -1.61803 -.618034        |
|                         -.618034 0        -.618034 -.618034 0               |
|                         -.618034 -1.61803 0        1        0               |
|                         0        1        0        1        1               |
|                         0        0        .381966  -1.61803 1               |
|                         0        1.38197  1        0        1               |
|                                                                             |
|            ring => RR                                                       |
|                      53                                                     |
|                          9                                                  |
|            target => RR                                                     |
|                        53                                                   |
|                          15                                                 |
|            source => RR                                                     |
|                        53                                                   |
|-----------------------------------------------------------------------------|
|                                                                             |
|.381966  0 -1       1        .381966  1        -1.61803 -.618034 -.618034    |
|.381966  0 -.618034 .381966  -1.61803 0        -1.61803 0        -.618034    |
|-.618034 1 0        0        .381966  -1.61803 1        .381966  0           |
|0        0 -.618034 -2.61803 1        .236068  0        .381966  0           |
|-1.61803 1 0        -.618034 0        .381966  -.618034 0        -.618034    |
|0        1 -.618034 0        -.618034 1        -1.61803 1        .381966     |
|1        1 0        1        1        1        0        1        1           |
|-1.61803 1 1        0        -1.61803 0        -.618034 -.618034 -.618034    |
|0        1 .381966  -1.61803 0        -1.61803 -1.61803 .381966  .381966     |
|-----------------------------------------------------------------------------|
|         }                                                                   |
|0                                                                            |
|4.23607                                                                      |
|0                                                                            |
|-1                                                                           |
|-.618034                                                                     |
|-.618034                                                                     |
|1                                                                            |
|1                                                                            |
|1                                                                            |
+-----------------------------------------------------------------------------+
|i10 : peek specificSlackMatrix "perles-matroid-QQ"                           |
|(dimension, 2)                                                               |
|                                                                             |
|o10 = Matrix{cache => CacheTable{}                                           |
|             RawMatrix => 0    1    a-3  -a+3 0    -a+3 0 -1   1    -a+3     |
|                          2a-5 1    0    0    -a+3 -a+3 0 -a+2 -a+3 a-2      |
|                          1    a    1    0    a    a-1  1 0    0    a        |
|                          1    0    a-1  -a+1 a-1  0    0 a-1  -a   1        |
|                          -a+2 0    -a+2 a-1  0    a-2  1 0    a-1  0        |
|                          -a+2 -a+1 0    1    0    0    1 a-1  0    -a+2     |
|                          0    1    0    1    1    1    1 0    1    1        |
|                          0    0    -a+3 a-2  1    a-2  1 1    0    a-2      |
|                          0    a+1  1    0    1    0    1 a    -a+1 0        |
|                                                                             |
|                        QQ[a]                                                |
|             ring => -----------                                             |
|                      2                                                      |
|                     a  - 3a + 1                                             |
|                       /   QQ[a]   \9                                        |
|             target => |-----------|                                         |
|                       | 2         |                                         |
|                       \a  - 3a + 1/                                         |
|                       /   QQ[a]   \15                                       |
|             source => |-----------|                                         |
|                       | 2         |                                         |
|                       \a  - 3a + 1/                                         |
|-----------------------------------------------------------------------------|
|                           }                                                 |
|1     a-2  -a+2 -a+2 0                                                       |
|0     a-2  0    -a+2 -2a+5                                                   |
|-a+1  1    a    0    0                                                       |
|-2a+1 0    a    0    -1                                                      |
|a     -a+2 0    a-1  a-1                                                     |
|1     -a+1 1    a    a-1                                                     |
|1     0    1    1    1                                                       |
|0     -a+2 a-1  a-1  1                                                       |
|-a+1  -a+1 a    a    1                                                       |
+-----------------------------------------------------------------------------+

Ways to use specificSlackMatrix:
================================

  * "specificSlackMatrix(String)"

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

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

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

The source of this document is in SlackIdeals.m2:1752:0.

symbolicSlackMatrix -- computes the symbolic slack matrix
*********************************************************

  * Usage:
        S = symbolicSlackMatrix V
        S = symbolicSlackMatrix X
        S = symbolicSlackMatrix M
        S = symbolicSlackMatrix P
        S = symbolicSlackMatrix C
  * Inputs:
      * V, a list (Macaulay2Doc), a list of points treated as the
        vertices of polytope; or vectors of a linear matroid if matroid is
        given as Object,; or a list of indices comprising the
        facets of an abstract polytope if abstractPolytope is given as
        Object.
      * X, a matrix (Macaulay2Doc), a slack matrix
      * M, a matroid (Matroids), a matroid
      * P, a convex polyhedron (Polyhedra), a polytope
      * C, a convex rational cone (Polyhedra), a cone
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        =>
        ..., default value QQ, specifies the coefficient ring of the underlying
        ring of the matrix
      * Object,
        => ..., default value "polytope", specify combinatorial object
      * Vars, =>
        ..., default value {}, specifies the variables to use to create the
        underlying ring of the matrix
  * Outputs:
      * S, a matrix (Macaulay2Doc), the symbolic slack matrix
        with indexed variables in symbol x

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

The symbolic slack matrix records the combinatorial structure of the given
object. Its (i, j)-entry is 0 if element i is in hyperplane j and it is a
variable otherwise. Variables are indexed left to right by rows.

+-------------------------------------------+
|i1 : V = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; |
+-------------------------------------------+
|i2 : S = symbolicSlackMatrix V             |
|                                           |
|Order of vertices is                       |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}           |
|                                           |
|o2 = | 0   x_0 0   x_1 |                   |
|     | x_2 0   0   x_3 |                   |
|     | 0   x_4 x_5 0   |                   |
|     | x_6 0   x_7 0   |                   |
|                                           |
|                        4                 4|
|o2 : Matrix (QQ[x ..x ])  <-- (QQ[x ..x ]) |
|                 0   7             0   7   |
+-------------------------------------------+
+-----------------------------------------------------------------------------+
|i3 : M = matroid({0, 1, 2, 3, 4, 5}, {{1, 2, 3}, {0, 2, 4}, {0, 3, 5}, {1, 4,|
|-----------------------------------------------------------------------------|
|5}}, EntryMode => "nonbases");                                               |
+-----------------------------------------------------------------------------+
|i4 : S = symbolicSlackMatrix M                                               |
|                                                                             |
|o4 = | x_0  0    x_1  x_2  0    x_3  0    |                                  |
|     | 0    x_4  x_5  x_6  x_7  0    0    |                                  |
|     | x_8  x_9  0    x_10 0    0    x_11 |                                  |
|     | x_12 0    x_13 0    x_14 0    x_15 |                                  |
|     | 0    x_16 x_17 0    0    x_18 x_19 |                                  |
|     | 0    0    0    x_20 x_21 x_22 x_23 |                                  |
|                                                                             |
|                         6                  7                                |
|o4 : Matrix (QQ[x ..x  ])  <-- (QQ[x ..x  ])                                 |
|                 0   23             0   23                                   |
+-----------------------------------------------------------------------------+
+--------------------------------------------------------------------------+
|i5 : V = {{1, 2, 3}, {4, 5, 6}, {1, 2, 4, 5}, {1, 3, 4, 6}, {2, 3, 5, 6}};|
+--------------------------------------------------------------------------+
|i6 : S = symbolicSlackMatrix(V, Object => "abstractPolytope")             |
|                                                                          |
|o6 = | 0    x_0 0    0   x_1 |                                            |
|     | 0    x_2 0    x_3 0   |                                            |
|     | 0    x_4 x_5  0   0   |                                            |
|     | x_6  0   0    0   x_7 |                                            |
|     | x_8  0   0    x_9 0   |                                            |
|     | x_10 0   x_11 0   0   |                                            |
|                                                                          |
|                         6                  5                             |
|o6 : Matrix (QQ[x ..x  ])  <-- (QQ[x ..x  ])                              |
|                 0   11             0   11                                |
+--------------------------------------------------------------------------+

See also
========

  * slackMatrix -- computes the slack matrix of a given
    realization
  * Object -- select the combinatorial object which the input
    should be interpreted as

Ways to use symbolicSlackMatrix:
================================

  * "symbolicSlackMatrix(Cone)"
  * "symbolicSlackMatrix(List)"
  * "symbolicSlackMatrix(Matrix)"
  * "symbolicSlackMatrix(Matroid)"
  * "symbolicSlackMatrix(Polyhedron)"

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

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

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

The source of this document is in SlackIdeals.m2:1803:0.

symbolicSlackMatrix(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the matrix
********************************************************************************************************************

  * Usage:
        symbolicSlackMatrix(..., CoefficientRing => QQ)
        symbolicSlackMatrix(..., CoefficientRing => ZZ/7)
        symbolicSlackMatrix(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: symbolicSlackMatrix, -- computes the
    symbolic slack matrix
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2830:0.

symbolicSlackMatrix(...,Object=>...) -- specify combinatorial object
********************************************************************

  * Usage:
        symbolicSlackMatrix(..., Object => "polytope")
        symbolicSlackMatrix(..., Object => "matroid")
        symbolicSlackMatrix(..., Object => "abstractPolytope")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: symbolicSlackMatrix, -- computes the
    symbolic slack matrix
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2546:0.

symbolicSlackMatrix(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the matrix
****************************************************************************************************************

  * Usage:
        symbolicSlackMatrix(..., Vars => {x_1..x_10})
        symbolicSlackMatrix(..., Vars => {a..z})
        symbolicSlackMatrix(..., Vars => {y_(1, 1)..y_(3, 4)})

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: symbolicSlackMatrix, -- computes the
    symbolic slack matrix
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2976:0.

symbolicSlackOfPlucker -- fill the slack matrix with Plücker variables
**********************************************************************

  * Usage:
        fillPl = symbolicSlackOfPlucker(v, B)
        fillPl = symbolicSlackOfPlucker(V, B)
        fillPl = symbolicSlackOfPlucker V
        fillPl = symbolicSlackOfPlucker(S, B)
        fillPl = symbolicSlackOfPlucker S
        fillPl = symbolicSlackOfPlucker P
        fillPl = symbolicSlackOfPlucker M
  * Inputs:
      * v, an integer (Macaulay2Doc), number of polytope vertices,
        cone generators, or matroid vectors
      * B, a list (Macaulay2Doc), set of hyperplane spanning set
        indices
      * V, a list (Macaulay2Doc), list of coordinates for polytope
        vertices, cone generators, or matroid vectors
      * S, a matrix (Macaulay2Doc), (symbolic) slack matrix
      * P, a convex polyhedron (Polyhedra), a polytope
      * M, a matroid (Matroids), a matroid
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        =>
        ..., default value QQ, specifies the coefficient ring of the underlying
        ring of the matrix
      * Object,
        => ..., default value "polytope", specify combinatorial object
  * Outputs:
      * fillPl, a matrix (Macaulay2Doc), slack matrix filled with
        Plücker variables

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

Given the number of polytope vertices, cone generators, or matroid vectors, or
a set of polytope vertices, cone generators, or matroid vectors, or a slack
matrix and a set of set of hyperplane spanning set indices, it fills the slack
matrix with Plücker variables.

+-----------------------------------------------------------------------------+
|i1 : v = 6;                                                                  |
+-----------------------------------------------------------------------------+
|i2 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};            |
+-----------------------------------------------------------------------------+
|i3 : fillPl = symbolicSlackOfPlucker(v, B)                                   |
|                                                                             |
|o3 = | -p_(0,1,2,4) 0           0            -p_(0,3,4,5) 0           |      |
|     | 0            p_(0,1,2,3) 0            -p_(1,3,4,5) 0           |      |
|     | 0            0           -p_(0,1,2,4) -p_(2,3,4,5) 0           |      |
|     | -p_(1,2,3,4) 0           -p_(0,1,3,4) 0            p_(0,1,2,3) |      |
|     | 0            p_(0,2,3,4) 0            0            p_(0,1,2,4) |      |
|     | p_(1,2,4,5)  p_(0,2,3,5) p_(0,1,4,5)  0            p_(0,1,2,5) |      |
|                                                                             |
|                                                                             |
|o3 : Matrix (QQ[p       ..p       , p       , p       , p       , p       ,  |
|                 0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4   1,2,3,4   0,1,2,5   |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5   1,2,4,5   0,3,4,5         |
|-----------------------------------------------------------------------------|
|                    6                                                        |
|p       , p       ])  <-- (QQ[p       ..p       , p       , p       ,        |
| 1,3,4,5   2,3,4,5             0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4         |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 1,2,3,4   0,1,2,5   0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5         |
|-----------------------------------------------------------------------------|
|                                        5                                    |
|p       , p       , p       , p       ])                                     |
| 1,2,4,5   0,3,4,5   1,3,4,5   2,3,4,5                                       |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i4 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}}; |
+-----------------------------------------------------------------------------+
|i5 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};            |
+-----------------------------------------------------------------------------+
|i6 : fillPl = symbolicSlackOfPlucker(V, B)                                   |
|                                                                             |
|o6 = | -p_(0,1,2,4) 0           0            -p_(0,3,4,5) 0           |      |
|     | 0            p_(0,1,2,3) 0            -p_(1,3,4,5) 0           |      |
|     | 0            0           -p_(0,1,2,4) -p_(2,3,4,5) 0           |      |
|     | -p_(1,2,3,4) 0           -p_(0,1,3,4) 0            p_(0,1,2,3) |      |
|     | 0            p_(0,2,3,4) 0            0            p_(0,1,2,4) |      |
|     | p_(1,2,4,5)  p_(0,2,3,5) p_(0,1,4,5)  0            p_(0,1,2,5) |      |
|                                                                             |
|                                                                             |
|o6 : Matrix (QQ[p       ..p       , p       , p       , p       , p       ,  |
|                 0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4   1,2,3,4   0,1,2,5   |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5   1,2,4,5   0,3,4,5         |
|-----------------------------------------------------------------------------|
|                    6                                                        |
|p       , p       ])  <-- (QQ[p       ..p       , p       , p       ,        |
| 1,3,4,5   2,3,4,5             0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4         |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 1,2,3,4   0,1,2,5   0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5         |
|-----------------------------------------------------------------------------|
|                                        5                                    |
|p       , p       , p       , p       ])                                     |
| 1,2,4,5   0,3,4,5   1,3,4,5   2,3,4,5                                       |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i7 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}}; |
+-----------------------------------------------------------------------------+
|i8 : fillPl = symbolicSlackOfPlucker V                                       |
|                                                                             |
|Input has been reordered to                                                  |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}, {0, 0, 1}, {1, 0, 1}}           |
|                                                                             |
|o8 = | 0            -p_(0,1,3,5) 0            0           -p_(0,2,3,4) |     |
|     | p_(0,1,2,4)  0            0            0           -p_(1,2,3,4) |     |
|     | 0            p_(1,2,3,5)  -p_(0,1,2,4) 0           0            |     |
|     | -p_(0,2,3,4) 0            -p_(0,1,3,4) p_(0,1,2,3) 0            |     |
|     | 0            -p_(1,3,4,5) 0            p_(0,1,2,4) 0            |     |
|     | p_(0,2,4,5)  0            p_(0,1,4,5)  p_(0,1,2,5) p_(2,3,4,5)  |     |
|                                                                             |
|                                                                             |
|o8 : Matrix (QQ[p       ..p       , p       , p       , p       , p       ,  |
|                 0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4   1,2,3,4   0,1,2,5   |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5   1,2,4,5   0,3,4,5         |
|-----------------------------------------------------------------------------|
|                    6                                                        |
|p       , p       ])  <-- (QQ[p       ..p       , p       , p       ,        |
| 1,3,4,5   2,3,4,5             0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4         |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 1,2,3,4   0,1,2,5   0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5         |
|-----------------------------------------------------------------------------|
|                                        5                                    |
|p       , p       , p       , p       ])                                     |
| 1,2,4,5   0,3,4,5   1,3,4,5   2,3,4,5                                       |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i9 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}}; |
+-----------------------------------------------------------------------------+
|i10 : B = {{1, 2, 4}, {0, 2, 3}, {0, 1, 4}, {3, 4, 5}, {0, 1, 2}};           |
+-----------------------------------------------------------------------------+
|i11 : fillPl = symbolicSlackOfPlucker(slackMatrix V, B)                      |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}, {0, 0, 1}, {1, 0, 1}}           |
|                                                                             |
|o11 = | -p_(0,1,2,4) 0           0            -p_(0,3,4,5) 0           |     |
|      | 0            p_(0,1,2,3) 0            -p_(1,3,4,5) 0           |     |
|      | 0            0           -p_(0,1,2,4) -p_(2,3,4,5) 0           |     |
|      | -p_(1,2,3,4) 0           -p_(0,1,3,4) 0            p_(0,1,2,3) |     |
|      | 0            p_(0,2,3,4) 0            0            p_(0,1,2,4) |     |
|      | p_(1,2,4,5)  p_(0,2,3,5) p_(0,1,4,5)  0            p_(0,1,2,5) |     |
|                                                                             |
|                                                                             |
|o11 : Matrix (QQ[p       ..p       , p       , p       , p       , p       , |
|                  0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4   1,2,3,4   0,1,2,5  |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5   1,2,4,5   0,3,4,5         |
|-----------------------------------------------------------------------------|
|                    6                                                        |
|p       , p       ])  <-- (QQ[p       ..p       , p       , p       ,        |
| 1,3,4,5   2,3,4,5             0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4         |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 1,2,3,4   0,1,2,5   0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5         |
|-----------------------------------------------------------------------------|
|                                        5                                    |
|p       , p       , p       , p       ])                                     |
| 1,2,4,5   0,3,4,5   1,3,4,5   2,3,4,5                                       |
+-----------------------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i12 : V = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {1, 0, 1}, {1, 1, 0}};|
+-----------------------------------------------------------------------------+
|i13 : fillPl = symbolicSlackOfPlucker(slackMatrix V)                         |
|                                                                             |
|Order of vertices is                                                         |
|{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {1, 1, 0}, {0, 0, 1}, {1, 0, 1}}           |
|                                                                             |
|o13 = | 0            -p_(0,1,3,5) 0            0           -p_(0,2,3,4) |    |
|      | p_(0,1,2,4)  0            0            0           -p_(1,2,3,4) |    |
|      | 0            p_(1,2,3,5)  -p_(0,1,2,4) 0           0            |    |
|      | -p_(0,2,3,4) 0            -p_(0,1,3,4) p_(0,1,2,3) 0            |    |
|      | 0            -p_(1,3,4,5) 0            p_(0,1,2,4) 0            |    |
|      | p_(0,2,4,5)  0            p_(0,1,4,5)  p_(0,1,2,5) p_(2,3,4,5)  |    |
|                                                                             |
|                                                                             |
|o13 : Matrix (QQ[p       ..p       , p       , p       , p       , p       , |
|                  0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4   1,2,3,4   0,1,2,5  |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5   1,2,4,5   0,3,4,5         |
|-----------------------------------------------------------------------------|
|                    6                                                        |
|p       , p       ])  <-- (QQ[p       ..p       , p       , p       ,        |
| 1,3,4,5   2,3,4,5             0,1,2,3   0,1,2,4   0,1,3,4   0,2,3,4         |
|-----------------------------------------------------------------------------|
|                                                                             |
|p       , p       , p       , p       , p       , p       , p       ,        |
| 1,2,3,4   0,1,2,5   0,1,3,5   0,2,3,5   1,2,3,5   0,1,4,5   0,2,4,5         |
|-----------------------------------------------------------------------------|
|                                        5                                    |
|p       , p       , p       , p       ])                                     |
| 1,2,4,5   0,3,4,5   1,3,4,5   2,3,4,5                                       |
+-----------------------------------------------------------------------------+

See also
========

  * getFacetBases -- get a list of d-spanning elements
    for each facet
  * slackFromPlucker -- fill the slack matrix of a
    given polytope, cone or matroid with Plücker coordinates
  * slackFromGalePlucker -- fill the slack matrix
    with Plücker coordinates of the Gale transform

Ways to use symbolicSlackOfPlucker:
===================================

  * "symbolicSlackOfPlucker(List)"
  * "symbolicSlackOfPlucker(List,List)"
  * "symbolicSlackOfPlucker(Matrix)"
  * "symbolicSlackOfPlucker(Matrix,List)"
  * "symbolicSlackOfPlucker(Matroid)"
  * "symbolicSlackOfPlucker(Polyhedron)"
  * "symbolicSlackOfPlucker(ZZ,List)"

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

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

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

The source of this document is in SlackIdeals.m2:1868:0.

symbolicSlackOfPlucker(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the matrix
***********************************************************************************************************************

  * Usage:
        symbolicSlackOfPlucker(..., CoefficientRing => QQ)
        symbolicSlackOfPlucker(..., CoefficientRing => ZZ/7)
        symbolicSlackOfPlucker(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: symbolicSlackOfPlucker, -- fill the
    slack matrix with Plücker variables
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2843:0.

symbolicSlackOfPlucker(...,Object=>...) -- specify combinatorial object
***********************************************************************

  * Usage:
        symbolicSlackOfPlucker(..., Object => "polytope")
        symbolicSlackOfPlucker(..., Object => "cone")
        symbolicSlackOfPlucker(..., Object => "matroid")

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

Indicates whether an input list should be treated as the vertices of a
polytope, the ground set of a matroid or the facets of an abstract polytope.

Functions with optional argument named Object:
==============================================

  * containsFlag(...,Object=>...)
    -- specify combinatorial
    object
  * cycleIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * findFlag(...,Object=>...)
    -- specify combinatorial
    object
  * getFacetBases(...,Object=>...)
    -- specify combinatorial
    object
  * graphicIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * grassmannSectionIdeal(...,Object=>...)
    -- specify
    combinatorial object
  * reducedSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * slackFromPlucker(...,Object=>...)
    -- specify
    combinatorial object
  * slackIdeal(...,Object=>...)
    -- specify combinatorial
    object
  * slackMatrix(...,Object=>...)
    -- specify combinatorial
    object
  * symbolicSlackMatrix(...,Object=>...)
    -- specify
    combinatorial object
  * symbolicSlackOfPlucker(...,Object=>...)
    -- specify
    combinatorial object

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

  * Default value: polytope
  * Function: symbolicSlackOfPlucker, -- fill the
    slack matrix with Plücker variables
  * Option key: Object, -- select the combinatorial object which
    the input should be interpreted as
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2561:0.

Tolerance -- choose the tolerance to approximate computations over the field RR
*******************************************************************************

  * Usage:
        slackFromGaleCircuits(G, Tolerance => 12)

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

The default value is 14.

See also
========

  * Strategy (Macaulay2Doc) -- an optional argument
  * slackFromGaleCircuits -- computes the slack
    matrix of a polytope from a Gale transform of the polytope

Functions with optional argument named Tolerance:
=================================================

  * slackFromGaleCircuits(...,Tolerance=>...)
    -- specifies
    the tolerance to compute the slack matrix of a polytope from a Gale
    transform of a polytope

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

The object Tolerance, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:3074:0.

toricPolytope -- computes the polytope whose toric ideal is the given ideal
***************************************************************************

  * Usage:
        Q = toricPolytope I
  * Inputs:
      * I, an ideal (Macaulay2Doc), a toric ideal
  * Outputs:
      * Q, a matrix (Macaulay2Doc), a matrix whose columns are
        the vectors of a configuration whose toric ideal is I

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

Every toric ideal comes as the ideal of some vector configuration. This
function gives one such vector configuration whose ideal is the given ideal.

+------------------------------------------+
|i1 : V = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};|
+------------------------------------------+
|i2 : I = slackIdeal V                     |
|                                          |
|Order of vertices is                      |
|{{0, 0}, {1, 0}, {0, 1}, {1, 1}}          |
|                                          |
|o2 = ideal(x x x x  - x x x x )           |
|            0 3 5 6    1 2 4 7            |
|                                          |
|o2 : Ideal of QQ[x ..x ]                  |
|                  0   7                   |
+------------------------------------------+
|i3 : Q = toricPolytope I                  |
|                                          |
|o3 = | 1 0 0 0 1  0  0 0 |                |
|     | 0 1 0 0 0  1  0 0 |                |
|     | 0 0 0 0 1  1  0 0 |                |
|     | 0 0 0 0 1  0  1 0 |                |
|     | 0 0 1 0 -1 0  0 0 |                |
|     | 0 0 0 0 0  1  0 1 |                |
|     | 0 0 0 1 0  -1 0 0 |                |
|                                          |
|              7       8                   |
|o3 : Matrix ZZ  <-- ZZ                    |
+------------------------------------------+

Caveat
======

This function does not test for binomiality. If it is given an ideal which is
not toric, it will return the polytope of the ideal whose generators are the
first two terms of each generator of the input ideal. If the input toric ideal
is scaled (lattice ideal with not all coefficients one) the toric polytope of
the unscaled ideal is returned.

See also
========

  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * cycleIdeal -- constructs the cycle ideal of a
    realization

Ways to use toricPolytope:
==========================

  * "toricPolytope(Ideal)"

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

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

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

The source of this document is in SlackIdeals.m2:2174:0.

universalIdeal -- computes the universal realization ideal of a matroid
***********************************************************************

  * Usage:
        U = universalIdeal M
        U = universalIdeal V
  * Inputs:
      * M, a matroid (Matroids), a matroid
      * V, a list (Macaulay2Doc), a list of points of a
        representation of a matroid
  * Optional inputs (Macaulay2Doc),:
      * CoefficientRing,
        => ...,
        default value QQ, specifies the coefficient ring of the underlying ring
        of the ideal
      * Vars, => ...,
        default value {}, specifies the variables to use to create the
        underlying ring of the ideal
  * Outputs:
      * U, an ideal (Macaulay2Doc), the universal realization
        ideal in Plücker and slack variables

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

The universal realization ideal defines a variety containing points (p, S)
which are pairs of a Plücker vector and a slack matrix coming from the same
realization of the matroid.

+-----------------------------------------------------------------------------+
|i1 : M = matroid({0, 1, 2, 3, 4, 5}, {{1, 2, 3}, {0, 2, 4}, {0, 3, 5}, {1, 4,|
|-----------------------------------------------------------------------------|
|5}}, EntryMode => "nonbases");                                               |
+-----------------------------------------------------------------------------+
|i2 : U = universalIdeal M                                                    |
|                                                                             |
|o2 = ideal (- p     p      + p     p     , - p     p      + p     p     ,    |
|               1,3,5 2,4,5    1,2,5 3,4,5     1,3,4 2,4,5    1,2,4 3,4,5     |
|     ------------------------------------------------------------------------|
|     p     p      + p     p     , p     p      + p     p     , p     p      +|
|      2,3,5 0,4,5    0,2,5 3,4,5   1,3,5 0,4,5    0,1,5 3,4,5   1,2,5 0,4,5  |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      - p     p     , p     p      + p     p     , |
|      0,1,5 2,4,5   2,3,4 0,4,5    0,3,4 2,4,5   1,3,4 0,4,5    0,1,4 3,4,5  |
|     ------------------------------------------------------------------------|
|     p     p      + p     p     , p     p      - p     p     , p     p      -|
|      1,2,4 0,4,5    0,1,4 2,4,5   0,1,3 2,4,5    0,1,2 3,4,5   2,3,4 1,3,5  |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - p     p      +           |
|      1,3,4 2,3,5     0,2,5 1,3,5    0,1,5 2,3,5     0,3,4 2,3,5             |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , p     p      +             |
|      0,2,3 3,4,5     0,3,4 1,3,5    0,1,3 3,4,5   0,1,4 2,3,5               |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , p     p      -             |
|      0,1,2 3,4,5     0,2,3 1,3,5    0,1,3 2,3,5   2,3,4 1,2,5               |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      - p     p     , p     p      + p     p      -|
|      1,2,4 2,3,5   1,3,4 1,2,5    1,2,4 1,3,5   0,3,4 1,2,5    0,1,4 2,3,5  |
|     ------------------------------------------------------------------------|
|     p     p      + p     p     , p     p      + p     p     , p     p      +|
|      0,1,3 2,4,5    0,1,2 3,4,5   2,3,4 0,2,5    0,2,3 2,4,5   1,3,4 0,2,5  |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      + p     p     , p     p      + p     p     , |
|      0,1,2 3,4,5   0,3,4 0,2,5    0,2,3 0,4,5   1,2,4 0,2,5    0,1,2 2,4,5  |
|     ------------------------------------------------------------------------|
|     - p     p      + p     p     , p     p      - p     p      +            |
|        0,2,3 1,2,5    0,1,2 2,3,5   2,3,4 0,1,5    0,1,4 2,3,5              |
|     ------------------------------------------------------------------------|
|     p     p      - p     p     , p     p      - p     p     , p     p      +|
|      0,1,3 2,4,5    0,1,2 3,4,5   1,3,4 0,1,5    0,1,4 1,3,5   0,3,4 0,1,5  |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      - p     p     , - p     p      +             |
|      0,1,3 0,4,5   1,2,4 0,1,5    0,1,4 1,2,5     0,1,4 0,2,5               |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , p     p      -             |
|      0,1,2 0,4,5     0,1,3 1,2,5    0,1,2 1,3,5   0,2,3 0,1,5               |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      + p     p     , - p     p      +             |
|      0,1,3 0,2,5   1,2,4 0,3,4    0,1,4 2,3,4     0,2,3 1,3,4               |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - p     p      +           |
|      0,1,3 2,3,4     0,2,3 1,2,4    0,1,2 2,3,4     0,1,3 1,2,4             |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      + p     p     , - x p      + x p     , -     |
|      0,1,2 1,3,4   0,2,3 0,1,4    0,1,2 0,3,4     8 0,4,5    0 2,4,5        |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , - x  p      + x p     , - x p      - x p     , -  |
|      12 0,4,5    0 3,4,5     12 2,4,5    8 3,4,5     8 0,1,4    0 1,2,4     |
|     ------------------------------------------------------------------------|
|     x  p      - x p     , x  p      - x p     , - p     p      -            |
|      12 0,1,4    0 1,3,4   12 1,2,4    8 1,3,4     1,2,4 0,4,5              |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      - p     p     , - p     p      +           |
|      0,1,4 2,4,5     1,3,4 0,4,5    0,1,4 3,4,5     1,3,4 2,4,5             |
|     ------------------------------------------------------------------------|
|     p     p     , - x p      - x p     , - x  p      - x p     , x  p      -|
|      1,2,4 3,4,5     8 0,1,5    0 1,2,5     12 0,1,5    0 1,3,5   12 1,2,5  |
|     ------------------------------------------------------------------------|
|     x p     , - p     p      - p     p     , - p     p      - p     p     , |
|      8 1,3,5     1,2,5 0,4,5    0,1,5 2,4,5     1,3,5 0,4,5    0,1,5 3,4,5  |
|     ------------------------------------------------------------------------|
|     - p     p      + p     p     , p     p      - p     p     , p     p     |
|        1,3,5 2,4,5    1,2,5 3,4,5   1,2,4 0,1,5    0,1,4 1,2,5   1,3,4 0,1,5|
|     ------------------------------------------------------------------------|
|     - p     p     , - p     p      + p     p     , x p      - x p     ,     |
|        0,1,4 1,3,5     1,3,4 1,2,5    1,2,4 1,3,5   9 0,1,5    4 0,2,5      |
|     ------------------------------------------------------------------------|
|     x  p      - x p     , x  p      - x p     , x p      - x p     ,        |
|      16 0,1,5    4 0,4,5   16 0,2,5    9 0,4,5   9 0,1,3    4 0,2,3         |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , x  p      + x p     , p     p      - p     p     ,|
|      16 0,1,3    4 0,3,4   16 0,2,3    9 0,3,4   0,2,3 0,1,5    0,1,3 0,2,5 |
|     ------------------------------------------------------------------------|
|     - p     p      - p     p     , - p     p      - p     p     , - x p     |
|        0,3,4 0,1,5    0,1,3 0,4,5     0,3,4 0,2,5    0,2,3 0,4,5     9 1,3,5|
|     ------------------------------------------------------------------------|
|     + x p     , - x  p      - x p     , - x  p      - x p     , p     p     |
|        4 2,3,5     16 1,3,5    4 3,4,5     16 2,3,5    9 3,4,5   0,2,5 1,3,5|
|     ------------------------------------------------------------------------|
|     - p     p     , p     p      + p     p     , p     p      +             |
|        0,1,5 2,3,5   1,3,5 0,4,5    0,1,5 3,4,5   2,3,5 0,4,5               |
|     ------------------------------------------------------------------------|
|     p     p     , p     p      - p     p     , - p     p      +             |
|      0,2,5 3,4,5   0,2,3 1,3,5    0,1,3 2,3,5     0,3,4 1,3,5               |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - x p      + x p     , -   |
|      0,1,3 3,4,5     0,3,4 2,3,5    0,2,3 3,4,5     5 0,2,5    1 1,2,5      |
|     ------------------------------------------------------------------------|
|     x  p      - x p     , - x  p      - x p     , - x  p      - x p     , - |
|      13 0,2,5    1 2,3,5     13 1,2,5    5 2,3,5     17 0,2,5    1 2,4,5    |
|     ------------------------------------------------------------------------|
|     x  p      - x p     , x  p      - x  p     , - x p      + x p     , -   |
|      17 1,2,5    5 2,4,5   17 2,3,5    13 2,4,5     6 0,3,4    2 1,3,4      |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , - x  p      + x p     , - x  p      + x p     , - |
|      10 0,3,4    2 2,3,4     10 1,3,4    6 2,3,4     20 0,3,4    2 3,4,5    |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , - x  p      + x  p     , x  p      - x p     ,    |
|      20 1,3,4    6 3,4,5     20 2,3,4    10 3,4,5   14 0,1,4    7 0,3,4     |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , x  p      + x  p     , - x  p      - x p     , -  |
|      21 0,1,4    7 0,4,5   21 0,3,4    14 0,4,5     14 1,2,4    7 2,3,4     |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , x  p      + x  p     , p     p      +             |
|      21 1,2,4    7 2,4,5   21 2,3,4    14 2,4,5   1,2,4 0,3,4               |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      - p     p     , p     p      -             |
|      0,1,4 2,3,4     1,2,4 0,4,5    0,1,4 2,4,5   2,3,4 0,4,5               |
|     ------------------------------------------------------------------------|
|     p     p     , x  p      + x p     , x  p      + x p     , - x  p      + |
|      0,3,4 2,4,5   14 0,1,2    7 0,2,3   21 0,1,2    7 0,2,5     21 0,2,3   |
|     ------------------------------------------------------------------------|
|     x  p     , - p     p      - p     p     , - p     p      + p     p     ,|
|      14 0,2,5     0,2,3 0,1,4    0,1,2 0,3,4     0,1,4 0,2,5    0,1,2 0,4,5 |
|     ------------------------------------------------------------------------|
|     - p     p      - p     p     , p     p      - p     p     , p     p     |
|        0,3,4 0,2,5    0,2,3 0,4,5   0,2,3 1,2,4    0,1,2 2,3,4   1,2,4 0,2,5|
|     ------------------------------------------------------------------------|
|     + p     p     , - p     p      - p     p     , - x  p      + x p     , -|
|        0,1,2 2,4,5     2,3,4 0,2,5    0,2,3 2,4,5     18 0,1,2    3 1,2,4   |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , - x  p      + x  p     , - x  p      + x p     , -|
|      22 0,1,2    3 1,2,5     22 1,2,4    18 1,2,5     18 0,1,3    3 1,3,4   |
|     ------------------------------------------------------------------------|
|     x  p      + x p     , - x  p      + x  p     , - p     p      +         |
|      22 0,1,3    3 1,3,5     22 1,3,4    18 1,3,5     0,1,3 1,2,4           |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - p     p      +           |
|      0,1,2 1,3,4     0,1,3 1,2,5    0,1,2 1,3,5     1,3,4 1,2,5             |
|     ------------------------------------------------------------------------|
|     p     p     , - x  p      + x p     , - x  p      + x p     , -         |
|      1,2,4 1,3,5     18 0,2,3    3 2,3,4     22 0,2,3    3 2,3,5            |
|     ------------------------------------------------------------------------|
|     x  p      + x  p     , - p     p      + p     p     , - p     p      +  |
|      22 2,3,4    18 2,3,5     0,2,3 1,2,4    0,1,2 2,3,4     0,2,3 1,2,5    |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - p     p      +           |
|      0,1,2 2,3,5     2,3,4 1,2,5    1,2,4 2,3,5     0,2,3 1,3,4             |
|     ------------------------------------------------------------------------|
|     p     p     , - p     p      + p     p     , - p     p      +           |
|      0,1,3 2,3,4     0,2,3 1,3,5    0,1,3 2,3,5     2,3,4 1,3,5             |
|     ------------------------------------------------------------------------|
|     p     p     , - x  p      + x  p     , - x  p      + x  p     , -       |
|      1,3,4 2,3,5     15 0,1,2    11 0,1,3     19 0,1,2    11 0,1,4          |
|     ------------------------------------------------------------------------|
|     x  p      + x  p     , - x  p      + x  p     , - x  p      + x  p     ,|
|      19 0,1,3    15 0,1,4     23 0,1,2    11 0,1,5     23 0,1,3    15 0,1,5 |
|     ------------------------------------------------------------------------|
|     - x  p      + x  p     )                                                |
|        23 0,1,4    19 0,1,5                                                 |
|                                                                             |
|o2 : Ideal of QQ[x ..x  , p     ..p     , p     , p     , p     , p     , p  |
|                  0   23   0,1,2   0,1,3   0,2,3   1,2,3   0,1,4   0,2,4   1,|
|-----------------------------------------------------------------------------|
|   , p     , p     , p     , p     , p     , p     , p     , p     , p     , |
|2,4   0,3,4   1,3,4   2,3,4   0,1,5   0,2,5   1,2,5   0,3,5   1,3,5   2,3,5  |
|-----------------------------------------------------------------------------|
|p     , p     , p     , p     ]                                              |
| 0,4,5   1,4,5   2,4,5   3,4,5                                               |
+-----------------------------------------------------------------------------+

Caveat
======

A list of points representing a matroid are always assumed to be in affine
space and are projectivized by appending 1 to vector of coordinates.

See also
========

  * slackMatrix -- computes the slack matrix of a given
    realization

Ways to use universalIdeal:
===========================

  * "universalIdeal(List)"
  * "universalIdeal(Matroid)"

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

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

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

The source of this document is in SlackIdeals.m2:2142:0.

universalIdeal(...,CoefficientRing=>...) -- specifies the coefficient ring of the underlying ring of the ideal
**************************************************************************************************************

  * Usage:
        universalIdeal(..., CoefficientRing => QQ)
        universalIdeal(..., CoefficientRing => ZZ/7)
        universalIdeal(..., CoefficientRing => GF(9))

See also
========

  * coefficientRing (Macaulay2Doc) -- get the
    coefficient ring

Functions with optional argument named CoefficientRing:
=======================================================

  * cycleIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * flattenRing(...,CoefficientRing=>...) (Macaulay2Doc),
    --
    specify the coefficient ring of the flattened ring
  * "generators(...,CoefficientRing=>...)" -- see generators(Ring) (Macaulay2Doc),
    -- the list of generators of a ring
  * graphicIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * "Grassmannian(...,CoefficientRing=>...)" -- see Grassmannian (Macaulay2Doc),
    -- compute the ideal of the Grassmannian of
    linear subspaces of a vector space
  * grassmannSectionIdeal(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "hibiIdeal(...,CoefficientRing=>...)" -- see hibiIdeal (Posets),
    -- produces the Hibi ideal of a poset
  * "hibiRing(...,CoefficientRing=>...)" -- see hibiRing (Posets),
    -- produces the Hibi ring of a poset
  * "idealChowRing(...,CoefficientRing=>...)" -- see idealChowRing (Matroids),
    -- the defining ideal of the Chow ring
  * idealOrlikSolomonAlgebra(...,CoefficientRing=>...) (missing documentation)
  * "orderComplex(...,CoefficientRing=>...)" -- see orderComplex (Posets),
    -- produces the order complex of a poset
  * "pPartitionRing(...,CoefficientRing=>...)" -- see pPartitionRing (Posets),
    -- produces the p-partition ring of a poset
  * reconstructSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * reducedSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the ideal
  * "Schubert(...,CoefficientRing=>...)" -- see Schubert (Macaulay2Doc),
    -- compute the Plücker ideal of a Schubert variety
  * slackIdeal(...,CoefficientRing=>...)
    -- specifies the
    coefficient ring of the underlying ring of the ideal
  * symbolicSlackMatrix(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * symbolicSlackOfPlucker(...,CoefficientRing=>...),
    --
    specifies the coefficient ring of the underlying ring of the matrix
  * universalIdeal(...,CoefficientRing=>...)
    -- specifies
    the coefficient ring of the underlying ring of the ideal

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

  * Default value: QQ (Macaulay2Doc),
  * Function: universalIdeal, -- computes the universal
    realization ideal of a matroid
  * Option key: CoefficientRing (Macaulay2Doc), -- an
    optional argument
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:2908:0.

universalIdeal(...,Vars=>...) -- specifies the variables to use to create the underlying ring of the ideal
**********************************************************************************************************

  * Usage:
        universalIdeal(..., Vars => {P, Q, R, S})
        universalIdeal(..., Vars => {a_0..a_12})
        universalIdeal(..., Vars => vars(-10..-3))

See also
========

  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

  * Default value: {}
  * Function: universalIdeal, -- computes the universal
    realization ideal of a matroid
  * Option key: Vars, -- give a set of variables for the polynomial
    ring where the object created will live
-------------------------------------------------------------------------------

The source of this document is in SlackIdeals.m2:3032:0.

Vars -- give a set of variables for the polynomial ring where the object created will live
******************************************************************************************

  * Usage:
        symbolicSlackMatrix(S, Vars => {x_1..x_10})
        slackIdeal(V, Vars => {a..z})
        cycleIdeal(M, Vars => {A, B, S, T})
        graphicIdeal(P, Vars => {y_(1, 1)..y_(5, 4)})
        universalIdeal(M, Vars => vars{3, 5, 7})
        reconstructSlackMatrix(S, {{0,1,2}}, Vars => {x})
        reducedSlackMatrix(S, Vars => {a,b,c,d,e,f,g,h,j,k,m,p})

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

This option is useful if you want to compare the object you will create with
one in an existing ring. The default value is {} which means the method will
create the necessary variables (in a new ring) for the constructed object.

See also
========

  * symbolicSlackMatrix -- computes the symbolic
    slack matrix
  * slackIdeal -- computes the slack ideal
  * cycleIdeal -- constructs the cycle ideal of a
    realization
  * graphicIdeal -- creates the toric ideal of the
    non-incidence graph of a polytope
  * universalIdeal -- computes the universal realization
    ideal of a matroid
  * reconstructSlackMatrix -- a list of facet
    labels that make up a flag in a polytope
  * reducedSlackMatrix -- a reduced slack matrix of
    a polytope
  * PolynomialRing (Macaulay2Doc) -- the class of all
    ordered monoid rings
  * vars (Macaulay2Doc) -- variables

Functions with optional argument named Vars:
============================================

  * cycleIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * graphicIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal
  * reconstructSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * reducedSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the ideal
  * slackIdeal(...,Vars=>...)
    -- specifies the variables to
    use to create the underlying ring of the ideal
  * symbolicSlackMatrix(...,Vars=>...)
    -- specifies the
    variables to use to create the underlying ring of the matrix
  * universalIdeal(...,Vars=>...)
    -- specifies the variables
    to use to create the underlying ring of the ideal

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

The object Vars, is a symbol (Macaulay2Doc).

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

The source of this document is in SlackIdeals.m2:2962:0.