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

SRdeformations -- Deformations of Stanley-Reisner rings and related computations.
*********************************************************************************

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

Overview:

The goal of this package is to provide a basic framework for deformations of
Stanley-Reisner rings, the deformations polytope, its tropical subcomplex and
tropical mirror symmetry in general.

This is work in progress, many interesting pieces still missing and more
testing is necessary. The efficiency and robustness of some of the pieces has
to be improved.

See the Macaulay 2 package repository for new versions of this file.

All suggestions and contributions are welcome.

Contents:

This package so far consists of the following parts:

The first part provides a data structure for deformations of monomial ideals
(including a toric grading). The class FirstOrderDeformation,
stores (and computes the dimension of) a big torus
graded part of the vector space of first order deformations (specified by a
Laurent monomial).

The second part gives an implementation of (not necessarily simplicial)
embedded complexes and co-complexes and their correspondence to monomial
ideals. The main focus here is on a flexible implementation, computing and
storing data only as soon as it is needed. See Complex,
CoComplex, Face.

The third part computes all first order deformations of Stanley-Reisner ideals
using part one and two via the results of Klaus Altmann and Jan Arthur
Christophersen who reduce the problem to links of faces of simplicial
complexes. See deformationsFace, and deform.

The fourth part gives functions to compute the first order deformations
polytope (see PT1) and its tropical subcocomplex (see
tropDef).

What' new:

May 13, 2025 (Version 0.53)

Minor changes to make the package compatible with Polyhedra,
(1.10).

Jul 13, 2010 (Version 0.52)

Some changes to ensure compatibility with the current version of OldPolyhedra
(1.1), in particular the method isSimplicial has been renamed to isSimp,
as OldPolyhedra is now using the name name isSimplicial.

Jan 28, 2010 (Version 0.51)

Minor changes to ensure compatibility with the previous M2 version 1.2. Note
that you will nevertheless need to install a more recent version of
OldPolyhedra which also works with 1.2 (tested with 1.0.6).

Oct 24, 2009 (Version 0.50)

Added methods addCokerGrading(PolynomialRing,List), and
raysPPn(List), to give the rays of the standard fan of weighted
projective space. Fixed a bug in the multigrading.

Oct 18, 2009 (Version 0.49)

Fixed a problem in convHull, (correspondence of
P.polytopalFacets with the vertices of the dual). This was only a problem when
using OldPolyhedra.m2.

Oct 6, 2009 (Version 0.48)

Resolved a compatibility issue with the new version of the M2 package
OldPolyhedra.

Oct 3, 2009 (Version 0.47)

Improvements to the documentation.

Sept 20, 2009 (Version 0.46)

Added a function hull, to compute the positive hull of a list of
vectors.

Sept 8, 2009 (Version 0.45)

Adjusted the methods using ConvexInterface.m2 to version 0.25 which now indexes
the vertices instead of using coordinates. This improves the performance
substantially.

Improved the computation of the dimension of a FirstOrderDeformation,
using a much smaller linear system of equations.

Fixed a bug in dim(Face).

Exported the symbol dualFace, which stores the dual of a face
to make this key available for the user.

See convHull, now stores in the faces their dimensions (see the key
indices).

Added an Option (Macaulay2Doc), file, to
convHull, and PT1, to store the result in a file. See
convHull, applied to a String (Macaulay2Doc), reads a
convex hull from a file.

Improved speed of globalSections, when dealing with
ideals in the Cox ring of projective space.

Added an optional key deform to complexes storing the associated deformations,
see deform.

Added functions saveDeformations, and
loadDeformations, to save to and load from a file the
deformations associated to a Complex.

Technical note:

In the future some of the methods and keys may change their name.

At some point Complex, and CoComplex, will get
a common ancestor.

Installation:

installPackage (Macaulay2Doc),("SRdeformations")

Options:

Computations with polyhedra are used in this package so far in by following
functions:

convHull, -- The convex hull complex

See globalSections, -- The global sections of a toric divisor

which again are called by PT1, deform, and
deformationsFace. If deform, and
deformationsFace, are used for Complex,es
inside a standard simplex, i.e., Stanley-Reisner ideals with the standard
projective space grading, then they don't rely on polyhedra computations.

There are two choices of M2 packages to be called for computations with
polyhedra:

Polyhedra,:

Works without additional configuration, but is not very fast.

It uses the M2 package FourierMotzkin.

To use Polyhedra do

See loadPackage (Macaulay2Doc),("SRdeformations",Configuration
=>\{"UseConvex"=>false\})

This is the standard configuration, i.e., it is synonymous to

See loadPackage (Macaulay2Doc),("SRdeformations")

See ConvexInterface,:

This package has to be installed first, see its documentation for this.

It calls the Maple package Convex and is faster than Polyhedra, hence the
preferable choice. If you want to do non-trivial examples you have to go for
it.

To use it type

See loadPackage (Macaulay2Doc),("SRdeformations",Configuration
=>\{"UseConvex"=>true\})

Note that you can change the standard option by editing the file
init-SRdeformations.m2 in the .Macaulay directory in your home directory (it
will be overwritten when you reinstall a newer version of the package, but
there will be a backup).

Examples:

mirrorSphere, uses the above functions to compute the
mirror sphere of a Calabi-Yau.

The author was supported by DFG (German Research Foundation) through Grant
BO3330/1-1.

Author
======

  * Janko Boehm (see http://www.math.uni-sb.de/ag/schreyer/jb/ )
    <boehm@mathematik.uni-kl.de>

Version
=======

This documentation describes version 0.53 of SRdeformations, released July 12,
2010.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{SRdeformationsSource,                                                  |
|  title = {{SRdeformations: deformations of Stanley-Reisner rings and related|
|  author = {Janko Boehm},                                                    |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|computations. Version~0.53}},                                                |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * CoComplex -- The class of all embedded co-complexes.
      * Complex -- The class of all embedded complexes.
      * Face -- The class of all faces of complexes or
        co-complexes.
      * FirstOrderDeformation -- The class of all
        first order deformations of monomial ideals.
  * Functions and commands
      * addCokerGrading -- Stores a cokernel grading in
        a polynomial ring.
      * addFaceDataToComplex -- Adds to a complex
        face data.
      * addFacetDataToComplex -- Adds to a
        complex facet data.
      * bigTorusDegree -- The big torus degree of a
        deformation.
      * boundaryCyclicPolytope -- The boundary
        complex of a cyclic polytope.
      * boundaryOfPolytope -- The boundary of a
        polytope.
      * closedStar -- The closed star of a face of a
        complex.
      * coComplex -- Make a co-complex.
      * coComplexToIdeal -- The monomial ideal
        associated to a CoComplex.
      * cokerElement -- Gives an element in the cokernel
        of a matrix.
      * complex -- Make a complex.
      * complexFromFacets -- Make a complex from its
        facets.
      * complexToIdeal -- The monomial ideal associated
        to a complex.
      * convHull -- The convex hull complex.
      * coordinates -- The coordinates of a face.
      * deform -- Compute the deformations associated to a
        Stanley-Reisner complex.
      * deformationsFace -- Compute the deformations
        associated to a face.
      * denominatorMonomial -- The denominator
        monomial of a deformation.
      * dualGrading -- The dual vertices of a polytope.
      * dualize -- The dual of a face or complex.
      * edim -- The embedding dimension of a complex or
        co-complex.
      * embeddingComplex -- The embedding complex of a
        complex or co-complex.
      * eulerCharacteristic -- The Euler
        characteristic of a complex.
      * face -- Generate a face.
      * faceToMonomial -- The monomial of a face.
      * facets -- The maximal faces of a complex.
      * fc -- The faces of a complex.
      * firstOrderDeformation -- Makes a first
        order deformation.
      * fullCyclicPolytope -- Cyclic polytope.
      * fvector -- The F-vector of a complex.
      * gensSource -- Generators of the source of a
        deformation.
      * globalSections -- The global sections of a toric
        divisor.
      * grading -- The grading of a first order deformation or
        complex or polynomial ring.
      * hull -- The positive hull complex.
      * idealToCoComplex -- The co-complex associated
        to a reduced monomial ideal.
      * idealToComplex -- The complex associated to a
        reduced monomial ideal.
      * intersectFaces -- The intersection of two faces.
      * isEquidimensional -- Check whether a complex
        or co-complex is equidimensional.
      * isNonzero -- Check whether a deformation is non-zero.
      * isPolytope -- Check whether a complex is a polytope.
      * isSimp -- Check whether a complex or co-complex is
        simplicial.
      * isSubface -- Checks whether a face is a subface of
        another face.
      * isTrivial -- Check whether a deformation is trivial.
      * iszero -- Tests whether something is zero.
      * joinVectors -- Converts a list of vectors to a
        matrix.
      * laurent -- Converts an exponent vector or a deformation
        into a Laurent monomial.
      * link -- The link of a face of a complex.
      * loadDeformations -- Read the deformation data
        of a complex from a file.
      * minimalNonFaces -- The minimal non-faces of a
        complex.
      * newEmptyComplex -- Generates an empty complex.
      * numeratorMonomial -- The numerator monomial
        of a deformation.
      * ofComplex -- The complex of a face.
      * parameters -- Parameters of a deformation.
      * polytopalFacets -- The facets of a polytope.
      * possibleDenominators -- Possible
        denominators of deformations.
      * preImage -- Compute the preimage.
      * PT1 -- Compute the deformation polytope associated to a
        Stanley-Reisner complex.
      * raysPPn -- The rays of the standard fan of projective
        space or weighted projective space.
      * relationsCoefficients -- Relations
        between the coefficients of a deformation.
      * saveDeformations -- Store the deformation data
        of a complex in a file.
      * simplex -- Simplex in the variables of a polynomial
        ring.
      * simplexDim -- The dimension of a face inside the
        vertex simplex.
      * simplexRing -- The underlying polynomial ring of a
        deformation or face or complex.
      * toHom -- Convert a first order deformation into a
        homomorphism.
      * totalSpace -- Total space of a deformation.
      * trivialDeformations -- Compute the trivial
        deformations.
      * tropDef -- The co-complex of tropical faces of the
        deformation polytope.
      * variables -- The variables of a complex or
        co-complex.
      * vectorToMonomial -- Converts an exponent
        vector into a monomial.
      * vert -- The vertices of a face or complex.
      * verticesDualPolytope -- The dual vertices
        of a polytope.
  * Methods
      * "addCokerGrading(PolynomialRing)" -- see addCokerGrading,
        -- Stores a cokernel grading in a polynomial ring.
      * "addCokerGrading(PolynomialRing,List)" -- see addCokerGrading,
        -- Stores a cokernel grading in a polynomial ring.
      * "addCokerGrading(PolynomialRing,Matrix)" -- see addCokerGrading,
        -- Stores a cokernel grading in a polynomial ring.
      * "addFaceDataToComplex(Complex,List)" -- see addFaceDataToComplex,
        -- Adds to a complex face data.
      * "addFaceDataToComplex(Complex,List,List)" -- see
        addFaceDataToComplex, -- Adds to a complex face
        data.
      * "addFacetDataToComplex(Complex,List)" -- see
        addFacetDataToComplex, -- Adds to a complex
        facet data.
      * "bigTorusDegree(FirstOrderDeformation)" -- see bigTorusDegree,
        -- The big torus degree of a deformation.
      * "boundaryCyclicPolytope(ZZ,PolynomialRing)" -- see
        boundaryCyclicPolytope, -- The boundary complex
        of a cyclic polytope.
      * "boundaryOfPolytope(Complex)" -- see boundaryOfPolytope,
        -- The boundary of a polytope.
      * "closedStar(Face,Complex)" -- see closedStar, -- The
        closed star of a face of a complex.
      * "coComplex(PolynomialRing,List)" -- see coComplex, --
        Make a co-complex.
      * "coComplex(PolynomialRing,List,List)" -- see coComplex,
        -- Make a co-complex.
      * "coComplex(PolynomialRing,List,List,PolynomialRing)" -- see
        coComplex, -- Make a co-complex.
      * "coComplex(PolynomialRing,List,PolynomialRing)" -- see coComplex,
        -- Make a co-complex.
      * "coComplexToIdeal(CoComplex)" -- see coComplexToIdeal,
        -- The monomial ideal associated to a CoComplex.
      * "cokerElement(Matrix,Matrix)" -- see cokerElement,
        -- Gives an element in the cokernel of a matrix.
      * "cokerElement(Vector,Matrix)" -- see cokerElement,
        -- Gives an element in the cokernel of a matrix.
      * complement(Complex) -- Compute the
        complement CoComplex.
      * complement(Face) -- Compute the complement
        face of a simplex.
      * "complex(PolynomialRing,List)" -- see complex, -- Make a
        complex.
      * "complex(PolynomialRing,List,List)" -- see complex, --
        Make a complex.
      * "complex(PolynomialRing,List,List,PolynomialRing)" -- see
        complex, -- Make a complex.
      * "complex(PolynomialRing,List,PolynomialRing)" -- see complex,
        -- Make a complex.
      * Complex == Complex -- Compare two complexes.
      * "complexFromFacets(PolynomialRing,List)" -- see
        complexFromFacets, -- Make a complex from its
        facets.
      * "complexFromFacets(PolynomialRing,List,PolynomialRing)" -- see
        complexFromFacets, -- Make a complex from its
        facets.
      * "complexToIdeal(Complex)" -- see complexToIdeal,
        -- The monomial ideal associated to a complex.
      * "convHull(List)" -- see convHull, -- The convex hull
        complex.
      * "convHull(String)" -- see convHull, -- The convex hull
        complex.
      * "coordinates(Face)" -- see coordinates, -- The
        coordinates of a face.
      * "coordinates(Face,Complex)" -- see coordinates, --
        The coordinates of a face.
      * "deform(Complex)" -- see deform, -- Compute the
        deformations associated to a Stanley-Reisner complex.
      * "deformationsFace(Face,Complex)" -- see deformationsFace,
        -- Compute the deformations associated to a face.
      * "deformationsFace(Face,Complex,Ideal)" -- see deformationsFace,
        -- Compute the deformations associated to a face.
      * degree(FirstOrderDeformation),
        -- The small torus degree of a deformation.
      * denominator(FirstOrderDeformation)
        -- The denominator of a
        deformation as a vector.
      * "denominatorMonomial(FirstOrderDeformation)" -- see
        denominatorMonomial, -- The denominator monomial
        of a deformation.
      * dim(Complex) -- Compute the dimension of a
        complex or co-complex.
      * dim(Face) -- Compute the dimension of a face.
      * dim(Face,Complex) -- Compute the
        dimension of a face.
      * dim(Face,PolynomialRing), --
        Compute the dimension of a face.
      * dim(FirstOrderDeformation), --
        Compute the dimension of a deformation.
      * "dualGrading(Complex)" -- see dualGrading, -- The
        dual vertices of a polytope.
      * "dualize(Complex)" -- see dualize, -- The dual of a face
        or complex.
      * "dualize(Face)" -- see dualize, -- The dual of a face or
        complex.
      * "edim(Complex)" -- see edim, -- The embedding dimension of
        a complex or co-complex.
      * "embeddingComplex(Complex)" -- see embeddingComplex,
        -- The embedding complex of a complex or co-complex.
      * "eulerCharacteristic(Complex)" -- see eulerCharacteristic,
        -- The Euler characteristic of a complex.
      * "eulerCharacteristic(List)" -- see eulerCharacteristic,
        -- The Euler characteristic of a complex.
      * "face(List)" -- see face, -- Generate a face.
      * "face(List,Complex)" -- see face, -- Generate a face.
      * "face(List,Complex,ZZ,ZZ)" -- see face, -- Generate a face.
      * "face(Set)" -- see face, -- Generate a face.
      * Face == Face -- Compare two faces.
      * "faceToMonomial(Face)" -- see faceToMonomial, --
        The monomial of a face.
      * "faceToMonomial(Face,PolynomialRing)" -- see faceToMonomial,
        -- The monomial of a face.
      * "facets(Complex)" -- see facets, -- The maximal faces of
        a complex.
      * "facets(List)" -- see facets, -- The maximal faces of a
        complex.
      * "fc(Complex)" -- see fc, -- The faces of a complex.
      * "fc(Complex,ZZ)" -- see fc, -- The faces of a complex.
      * "firstOrderDeformation(Ideal,Vector)" -- see
        firstOrderDeformation, -- Makes a first order
        deformation.
      * "firstOrderDeformation(Matrix,Vector)" -- see
        firstOrderDeformation, -- Makes a first order
        deformation.
      * "firstOrderDeformation(MonomialIdeal,Vector)" -- see
        firstOrderDeformation, -- Makes a first order
        deformation.
      * FirstOrderDeformation == FirstOrderDeformation
        -- Compare two first
        order deformations.
      * "fullCyclicPolytope(ZZ,PolynomialRing)" -- see
        fullCyclicPolytope, -- Cyclic polytope.
      * "fullCyclicPolytope(ZZ,PolynomialRing,PolynomialRing)" -- see
        fullCyclicPolytope, -- Cyclic polytope.
      * "fvector(Complex)" -- see fvector, -- The F-vector of a
        complex.
      * "fvector(List)" -- see fvector, -- The F-vector of a
        complex.
      * "gensSource(FirstOrderDeformation)" -- see gensSource,
        -- Generators of the source of a deformation.
      * "globalSections(Matrix,Vector)" -- see globalSections,
        -- The global sections of a toric divisor.
      * "globalSections(Matrix,Vector,List)" -- see globalSections,
        -- The global sections of a toric divisor.
      * grading(Complex) -- The grading of a
        complex.
      * grading(FirstOrderDeformation)
        -- The small torus grading of a
        deformation.
      * grading(PolynomialRing) -- The
        coker grading of a polynomial ring.
      * HH Complex -- Compute the homology of a complex.
      * "hull(List)" -- see hull, -- The positive hull complex.
      * "hull(String)" -- see hull, -- The positive hull complex.
      * "idealToCoComplex(Ideal)" -- see idealToCoComplex,
        -- The co-complex associated to a reduced monomial
        ideal.
      * "idealToCoComplex(Ideal,Complex)" -- see idealToCoComplex,
        -- The co-complex associated to a reduced monomial
        ideal.
      * "idealToCoComplex(MonomialIdeal)" -- see idealToCoComplex,
        -- The co-complex associated to a reduced monomial
        ideal.
      * "idealToCoComplex(MonomialIdeal,Complex)" -- see
        idealToCoComplex, -- The co-complex associated to a
        reduced monomial ideal.
      * "idealToComplex(Ideal)" -- see idealToComplex, --
        The complex associated to a reduced monomial ideal.
      * "idealToComplex(Ideal,Complex)" -- see idealToComplex,
        -- The complex associated to a reduced monomial ideal.
      * "idealToComplex(MonomialIdeal)" -- see idealToComplex,
        -- The complex associated to a reduced monomial ideal.
      * "idealToComplex(MonomialIdeal,Complex)" -- see idealToComplex,
        -- The complex associated to a reduced monomial ideal.
      * indices(Face) -- The indices of a face.
      * "intersectFaces(Face,Face)" -- see intersectFaces,
        -- The intersection of two faces.
      * "intersectFaces(List)" -- see intersectFaces, --
        The intersection of two faces.
      * "isEquidimensional(Complex)" -- see isEquidimensional,
        -- Check whether a complex or co-complex is
        equidimensional.
      * "isEquidimensional(List)" -- see isEquidimensional,
        -- Check whether a complex or co-complex is
        equidimensional.
      * isHomogeneous(FirstOrderDeformation)
        -- Check whether a
        deformation is homogeneous.
      * "isNonzero(FirstOrderDeformation)" -- see isNonzero,
        -- Check whether a deformation is non-zero.
      * "isPolytope(Complex)" -- see isPolytope, -- Check
        whether a complex is a polytope.
      * "isPolytope(List)" -- see isPolytope, -- Check
        whether a complex is a polytope.
      * "isSimp(Complex)" -- see isSimp, -- Check whether a
        complex or co-complex is simplicial.
      * "isSimp(List)" -- see isSimp, -- Check whether a complex
        or co-complex is simplicial.
      * "isSubface(Face,Face)" -- see isSubface, -- Checks
        whether a face is a subface of another face.
      * "isTrivial(FirstOrderDeformation)" -- see isTrivial,
        -- Check whether a deformation is trivial.
      * "isTrivial(Vector)" -- see isTrivial, -- Check whether
        a deformation is trivial.
      * "iszero(Thing)" -- see iszero, -- Tests whether something
        is zero.
      * "joinVectors(List)" -- see joinVectors, -- Converts
        a list of vectors to a matrix.
      * "laurent(FirstOrderDeformation)" -- see laurent, --
        Converts an exponent vector or a deformation into a Laurent monomial.
      * "laurent(Vector,PolynomialRing)" -- see laurent, --
        Converts an exponent vector or a deformation into a Laurent monomial.
      * "link(Face,Complex)" -- see link, -- The link of a face of
        a complex.
      * "loadDeformations(Complex,String)" -- see loadDeformations,
        -- Read the deformation data of a complex from a
        file.
      * "minimalNonFaces(Complex)" -- see minimalNonFaces,
        -- The minimal non-faces of a complex.
      * net(Complex) -- Printing complexes.
      * net(Face) -- Printing faces.
      * net(FirstOrderDeformation), --
        Pretty print for deformations.
      * "newEmptyComplex(PolynomialRing)" -- see newEmptyComplex,
        -- Generates an empty complex.
      * numerator(FirstOrderDeformation)
        -- The numerator of a deformation
        as a vector.
      * "numeratorMonomial(FirstOrderDeformation)" -- see
        numeratorMonomial, -- The numerator monomial of a
        deformation.
      * "ofComplex(Face)" -- see ofComplex, -- The complex of
        a face.
      * "parameters(FirstOrderDeformation)" -- see parameters,
        -- Parameters of a deformation.
      * "parameters(Matrix,Vector)" -- see parameters, --
        Parameters of a deformation.
      * "polytopalFacets(Complex)" -- see polytopalFacets,
        -- The facets of a polytope.
      * "possibleDenominators(Ideal)" -- see possibleDenominators,
        -- Possible denominators of deformations.
      * "possibleDenominators(Ideal,List)" -- see possibleDenominators,
        -- Possible denominators of deformations.
      * "possibleDenominators(List,List)" -- see possibleDenominators,
        -- Possible denominators of deformations.
      * "preImage(Matrix,Vector)" -- see preImage, -- Compute
        the preimage.
      * "PT1(Complex)" -- see PT1, -- Compute the deformation
        polytope associated to a Stanley-Reisner complex.
      * "raysPPn(List)" -- see raysPPn, -- The rays of the
        standard fan of projective space or weighted projective space.
      * "raysPPn(ZZ)" -- see raysPPn, -- The rays of the
        standard fan of projective space or weighted projective space.
      * "relationsCoefficients(FirstOrderDeformation)" -- see
        relationsCoefficients, -- Relations between the
        coefficients of a deformation.
      * "relationsCoefficients(Matrix,Vector)" -- see
        relationsCoefficients, -- Relations between the
        coefficients of a deformation.
      * "saveDeformations(Complex,String)" -- see saveDeformations,
        -- Store the deformation data of a complex in a file.
      * "simplex(PolynomialRing)" -- see simplex, -- Simplex in
        the variables of a polynomial ring.
      * "simplex(PolynomialRing,PolynomialRing)" -- see simplex,
        -- Simplex in the variables of a polynomial ring.
      * "simplexDim(Face)" -- see simplexDim, -- The
        dimension of a face inside the vertex simplex.
      * simplexRing(Complex) -- The underlying
        polynomial ring of a complex.
      * simplexRing(Face) -- The underlying
        polynomial ring of a face.
      * simplexRing(FirstOrderDeformation)
        -- The underlying polynomial
        ring of a deformation or face.
      * source(FirstOrderDeformation),
        -- The source of a deformation.
      * target(FirstOrderDeformation),
        -- The target of a deformation.
      * "toHom(FirstOrderDeformation)" -- see toHom, -- Convert a
        first order deformation into a homomorphism.
      * "totalSpace(FirstOrderDeformation,PolynomialRing)" -- see
        totalSpace, -- Total space of a deformation.
      * "totalSpace(List,PolynomialRing)" -- see totalSpace,
        -- Total space of a deformation.
      * "trivialDeformations(Complex)" -- see trivialDeformations,
        -- Compute the trivial deformations.
      * "trivialDeformations(Ideal,Matrix)" -- see trivialDeformations,
        -- Compute the trivial deformations.
      * "trivialDeformations(Matrix)" -- see trivialDeformations,
        -- Compute the trivial deformations.
      * "tropDef(Complex,Complex)" -- see tropDef, -- The
        co-complex of tropical faces of the deformation polytope.
      * "variables(Complex)" -- see variables, -- The
        variables of a complex or co-complex.
      * "vectorToMonomial(Vector,PolynomialRing)" -- see
        vectorToMonomial, -- Converts an exponent vector into
        a monomial.
      * "vert(Complex)" -- see vert, -- The vertices of a face or
        complex.
      * "vert(Face)" -- see vert, -- The vertices of a face or
        complex.
      * "verticesDualPolytope(Complex)" -- see verticesDualPolytope,
        -- The dual vertices of a polytope.
  * Symbols
      * complementComplex -- Optional data of
        Complex.
      * computeFaces -- Compute faces of a simplex.
      * dualComplex -- Optional data of Complex.
      * dualFace -- Optional data of Face.
      * embedded -- Use only faces of the embedding complex.
      * file -- Store result of a computation in a file.
      * mirrorSphere -- Example how to compute the mirror
        sphere.
      * noBoundary -- Optional data of Complex.

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

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

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

The source of this document is in SRdeformations.m2:4000:0.

addCokerGrading -- Stores a cokernel grading in a polynomial ring.
******************************************************************

  * Usage:
        addCokerGrading(R)
        addCokerGrading(R,L)
        addCokerGrading(R,A)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
      * A, a matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc), the integer grading matrix.

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

Stores a cokernel grading (Cox grading) in a polynomial ring. This data is
accessed by FirstOrderDeformation, to compute the
small torus degree(FirstOrderDeformation),
of a deformation, and by Complex,
and CoComplex, to store the vertices.

The number or rows of A has to match the number of variables of R.

If A is not specified, see raysPPn, R is used.

If L is specified then the grading of a weighted projective space is added.

This command does not change the behaviour of R with respect to the standard
Macaulay2 image grading, which we want to use independently.

+------------------------+
|i1 : R=QQ[x_0..x_4];    |
+------------------------+
|i2 : addCokerGrading(R);|
|                        |
|              5       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : R.grading          |
|                        |
|o3 = | -1 -1 -1 -1 |    |
|     | 1  0  0  0  |    |
|     | 0  1  0  0  |    |
|     | 0  0  1  0  |    |
|     | 0  0  0  1  |    |
|                        |
|              5       4 |
|o3 : Matrix ZZ  <-- ZZ  |
+------------------------+

Weighted projective space:

+------------------------------------+
|i4 : R=QQ[x_0..x_4];                |
+------------------------------------+
|i5 : addCokerGrading(R,{1,1,2,2,3});|
|                                    |
|              5       4             |
|o5 : Matrix ZZ  <-- ZZ              |
+------------------------------------+
|i6 : R.grading                      |
|                                    |
|o6 = | -1 -2 -2 -3 |                |
|     | 1  0  0  0  |                |
|     | 0  1  0  0  |                |
|     | 0  0  1  0  |                |
|     | 0  0  0  1  |                |
|                                    |
|              5       4             |
|o6 : Matrix ZZ  <-- ZZ              |
+------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * raysPPn -- The rays of the standard fan of projective space
    or weighted projective space.

Ways to use addCokerGrading:
============================

  * "addCokerGrading(PolynomialRing)"
  * "addCokerGrading(PolynomialRing,List)"
  * "addCokerGrading(PolynomialRing,Matrix)"

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

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

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

The source of this document is in SRdeformations.m2:5148:0.

addFaceDataToComplex -- Adds to a complex face data.
****************************************************

  * Usage:
        addFaceDataToComplex(C,facelist)
        addFaceDataToComplex(C,facelist,facetlist)
  * Inputs:
      * C, an embedded complex,
      * facelist, a list (Macaulay2Doc), whose i-th entry is a list
        of the faces of C of dimension i-1
      * facetlist, a list (Macaulay2Doc), whose i-th entry is a
        list of the facets of C of dimension i-1
  * Outputs:
      * C, an embedded complex,

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

Adds to a complex the face data and facet data (computed if not specified),
i.e., C.fc, C.facets, C.dim, C.fvector, C.isEquidimensional, C.isSimp are
updated.

This allows us to add the face data later to a complex generated previously by
newEmptyComplex.

Note that the input C is modified by this method.

This function is mainly used internally, but may occasionally be useful to the
user and is hence exported.

+-------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                      |
|                                                                         |
|o1 = R                                                                   |
|                                                                         |
|o1 : PolynomialRing                                                      |
+-------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                  |
|                                                                         |
|o2 = | -1 -1 -1 -1 |                                                     |
|     | 1  0  0  0  |                                                     |
|     | 0  1  0  0  |                                                     |
|     | 0  0  1  0  |                                                     |
|     | 0  0  0  1  |                                                     |
|                                                                         |
|              5       4                                                  |
|o2 : Matrix ZZ  <-- ZZ                                                   |
+-------------------------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                         |
|o3 = ideal (x x , x x , x x , x x , x x )                                |
|             0 1   1 2   2 3   3 4   0 4                                 |
|                                                                         |
|o3 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i4 : C=idealToComplex(I)                                                 |
|                                                                         |
|o4 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o4 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i5 : Cl=newEmptyComplex(R)                                               |
|                                                                         |
|o5 = empty complex                                                       |
|                                                                         |
|o5 : complex of dim -1 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial                                         |
+-------------------------------------------------------------------------+
|i6 : addFaceDataToComplex(Cl,fc C)                                       |
|                                                                         |
|o6 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o6 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i7 : Cl==C                                                               |
|                                                                         |
|o7 = true                                                                |
+-------------------------------------------------------------------------+

Caveat
======

If both facelist and facetlist are specified this function does not make any
consistency check.

See also
========

  * newEmptyComplex -- Generates an empty complex.
  * dim (Macaulay2Doc) -- compute the Krull dimension
  * fvector -- The F-vector of a complex.
  * fc -- The faces of a complex.
  * isSimp -- Check whether a complex or co-complex is
    simplicial.
  * isEquidimensional -- Check whether a complex or
    co-complex is equidimensional.

Ways to use addFaceDataToComplex:
=================================

  * "addFaceDataToComplex(Complex,List)"
  * "addFaceDataToComplex(Complex,List,List)"

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

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

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

The source of this document is in SRdeformations.m2:7194:0.

addFacetDataToComplex -- Adds to a complex facet data.
******************************************************

  * Usage:
        addFacetDataToComplex(C,facetlist)
  * Inputs:
      * C, an embedded complex,
      * facetlist, a list (Macaulay2Doc), whose i-th entry is a
        list of the facets of C of dimension i-1
  * Outputs:
      * C, an embedded complex,

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

Adds to a complex the facet data, i.e., C.facets, C.dim, C.fvector,
C.isEquidimensional, C.isSimp are updated.

This allows us to add the facet data later to a complex generated previously by
newEmptyComplex.

Note that the input C is modified by this method.

This function is mainly used internally, but may occasionally be useful to the
user and is hence exported.

+-------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                      |
|                                                                         |
|o1 = R                                                                   |
|                                                                         |
|o1 : PolynomialRing                                                      |
+-------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                  |
|                                                                         |
|o2 = | -1 -1 -1 -1 |                                                     |
|     | 1  0  0  0  |                                                     |
|     | 0  1  0  0  |                                                     |
|     | 0  0  1  0  |                                                     |
|     | 0  0  0  1  |                                                     |
|                                                                         |
|              5       4                                                  |
|o2 : Matrix ZZ  <-- ZZ                                                   |
+-------------------------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                         |
|o3 = ideal (x x , x x , x x , x x , x x )                                |
|             0 1   1 2   2 3   3 4   0 4                                 |
|                                                                         |
|o3 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i4 : C=idealToComplex(I)                                                 |
|                                                                         |
|o4 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o4 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i5 : Cl=newEmptyComplex(R)                                               |
|                                                                         |
|o5 = empty complex                                                       |
|                                                                         |
|o5 : complex of dim -1 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial                                         |
+-------------------------------------------------------------------------+
|i6 : addFacetDataToComplex(Cl,facets C)                                  |
|                                                                         |
|o6 = done                                                                |
+-------------------------------------------------------------------------+
|i7 : Cl==C                                                               |
|                                                                         |
|o7 = true                                                                |
+-------------------------------------------------------------------------+

See also
========

  * newEmptyComplex -- Generates an empty complex.
  * addFaceDataToComplex -- Adds to a complex face
    data.
  * dim (Macaulay2Doc) -- compute the Krull dimension
  * fvector -- The F-vector of a complex.
  * facets -- The maximal faces of a complex.
  * isSimp -- Check whether a complex or co-complex is
    simplicial.
  * isEquidimensional -- Check whether a complex or
    co-complex is equidimensional.

Ways to use addFacetDataToComplex:
==================================

  * "addFacetDataToComplex(Complex,List)"

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

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

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

The source of this document is in SRdeformations.m2:7239:0.

bigTorusDegree -- The big torus degree of a deformation.
********************************************************

  * Usage:
        bigTorusDegree(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a vector (Macaulay2Doc),

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

Returns the exponent vector of the Laurent monomial representing f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                   |
|                                                      |
|o1 = R                                                |
|                                                      |
|o1 : PolynomialRing                                   |
+------------------------------------------------------+
|i2 : addCokerGrading(R)                               |
|                                                      |
|o2 = | -1 -1 -1 -1 |                                  |
|     | 1  0  0  0  |                                  |
|     | 0  1  0  0  |                                  |
|     | 0  0  1  0  |                                  |
|     | 0  0  0  1  |                                  |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : bigTorusDegree f                                 |
|                                                      |
|o6 = | -1 |                                           |
|     | -1 |                                           |
|     |  0 |                                           |
|     |  2 |                                           |
|     |  0 |                                           |
|                                                      |
|       5                                              |
|o6 : ZZ                                               |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use bigTorusDegree:
===========================

  * "bigTorusDegree(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4368:0.

boundaryCyclicPolytope -- The boundary complex of a cyclic polytope.
********************************************************************

  * Usage:
        boundaryCyclicPolytope(d,R)
  * Inputs:
      * d, an integer (Macaulay2Doc), positive
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an embedded complex,

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

Returns the boundary complex of a cyclic polytope of dimension d inside the
standard simplex of the variables of R. So the vertices are those of the
standard simplex.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                         |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : boundaryCyclicPolytope(3,R)                                            |
|                                                                            |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x              |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5             |
|                                                                            |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1|
+----------------------------------------------------------------------------+

See also
========

  * fullCyclicPolytope -- Cyclic polytope.

Ways to use boundaryCyclicPolytope:
===================================

  * "boundaryCyclicPolytope(ZZ,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:6129:0.

boundaryOfPolytope -- The boundary of a polytope.
*************************************************

  * Usage:
        boundaryOfPolytope(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

Returns the boundary of a complex C which is a polytope.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : C=simplex(R)                                                          |
|                                                                           |
|o2 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i3 : isPolytope C                                                          |
|                                                                           |
|o3 = true                                                                  |
+---------------------------------------------------------------------------+
|i4 : boundaryOfPolytope C                                                  |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+

Ways to use boundaryOfPolytope:
===============================

  * "boundaryOfPolytope(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6102:0.

closedStar -- The closed star of a face of a complex.
*****************************************************

  * Usage:
        closedStar(F)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

The closed star of the face F of the complex C.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : C=boundaryOfPolytope simplex(R)                                       |
|                                                                           |
|o2 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o2 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i3 : F=C.fc_0_0                                                            |
|                                                                           |
|o3 = x                                                                     |
|      0                                                                    |
|                                                                           |
|o3 : face with 1 vertex                                                    |
+---------------------------------------------------------------------------+
|i4 : link(F,C)                                                             |
|                                                                           |
|o4 = 2: x x x  x x x  x x x  x x x                                         |
|         1 2 3  1 2 4  1 3 4  2 3 4                                        |
|                                                                           |
|o4 : complex of dim 2 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 4, 6, 4, 0, 0}, Euler = 1   |
+---------------------------------------------------------------------------+
|i5 : closedStar(F,C)                                                       |
|                                                                           |
|o5 = 3: x x x x  x x x x  x x x x  x x x x                                 |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4                                |
|                                                                           |
|o5 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 4, 0}, Euler = 0 |
+---------------------------------------------------------------------------+
|i6 : F=C.fc_1_0                                                            |
|                                                                           |
|o6 = x x                                                                   |
|      0 1                                                                  |
|                                                                           |
|o6 : face with 2 vertices                                                  |
+---------------------------------------------------------------------------+
|i7 : link(F,C)                                                             |
|                                                                           |
|o7 = 1: x x  x x  x x                                                      |
|         2 3  2 4  3 4                                                     |
|                                                                           |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 3, 3, 0, 0, 0}, Euler = -1  |
+---------------------------------------------------------------------------+
|i8 : closedStar(F,C)                                                       |
|                                                                           |
|o8 = 3: x x x x  x x x x  x x x x                                          |
|         0 1 2 3  0 1 2 4  0 1 3 4                                         |
|                                                                           |
|o8 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 9, 3, 0}, Euler = 0  |
+---------------------------------------------------------------------------+

+--------------------------------------------------------------------------+
|i9 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o9 = R                                                                    |
|                                                                          |
|o9 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i10 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                          |
|o10 = ideal (x x , x x , x x , x x , x x )                                |
|              0 1   1 2   2 3   3 4   0 4                                 |
|                                                                          |
|o10 : Ideal of R                                                          |
+--------------------------------------------------------------------------+
|i11 : C=idealToComplex I                                                  |
|                                                                          |
|o11 = 1: x x  x x  x x  x x  x x                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o11 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+
|i12 : F=C.fc_0_0                                                          |
|                                                                          |
|o12 = x                                                                   |
|       0                                                                  |
|                                                                          |
|o12 : face with 1 vertex                                                  |
+--------------------------------------------------------------------------+
|i13 : link(F,C)                                                           |
|                                                                          |
|o13 = 0: x  x                                                             |
|          2  3                                                            |
|                                                                          |
|o13 : complex of dim 0 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 2, 0, 0, 0, 0}, Euler = 1 |
+--------------------------------------------------------------------------+
|i14 : closedStar(F,C)                                                     |
|                                                                          |
|o14 = 1: x x  x x                                                         |
|          0 2  0 3                                                        |
|                                                                          |
|o14 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 3, 2, 0, 0, 0}, Euler = 0 |
+--------------------------------------------------------------------------+
|i15 : F=C.fc_1_0                                                          |
|                                                                          |
|o15 = x x                                                                 |
|       0 2                                                                |
|                                                                          |
|o15 : face with 2 vertices                                                |
+--------------------------------------------------------------------------+
|i16 : link(F,C)                                                           |
|                                                                          |
|o16 = -1: {}                                                              |
|                                                                          |
|o16 : complex of dim -1 embedded in dim 4 (printing facets)               |
|      equidimensional, simplicial, F-vector {1, 0, 0, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+
|i17 : closedStar(F,C)                                                     |
|                                                                          |
|o17 = 1: x x                                                              |
|          0 2                                                             |
|                                                                          |
|o17 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 2, 1, 0, 0, 0}, Euler = 0 |
+--------------------------------------------------------------------------+

See also
========

  * link -- The link of a face of a complex.

Ways to use closedStar:
=======================

  * "closedStar(Face,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:5900:0.

CoComplex -- The class of all embedded co-complexes.
****************************************************

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

The class of all embedded co-complexes, not necessarily simplicial.

Creating co-complexes:

The following functions return co-complexes:

idealToCoComplex, -- The co-complex associated to a
reduced monomial ideal

See dualize, -- The dual of a complex.

See complement (Macaulay2Doc), -- The complement of a complex.

See coComplex, -- Make a co-complex from a list of faces

For further examples see the documentation of these functions.

The data stored in a co-complex C:

C.simplexRing, the polynomial ring of vertices of C (note these are only faces
of C if C is a polytope).

C.grading, is C.simplexRing.grading, a matrix with the coordinates of the
vertices of C in its rows.

C.facets, a list with the facets of C sorted into lists by dimension.

C.edim, the embedding dimension of C, i.e., see rank (Macaulay2Doc),
source (Macaulay2Doc), C.grading.

C.dim, the dimension of C, i.e., the minimal dimension of the faces.

C.isSimp, a Boolean (Macaulay2Doc), indicating whether C is
simplicial.

C.isEquidimensional, a Boolean (Macaulay2Doc), indicating whether
C is equidimensional.

C.fc, a ScriptedFunctor (Macaulay2Doc), with the faces of
C sorted and indexed by dimension.

C.fvector, a List (Macaulay2Doc), with the F-vector of C.

The following may be present (if known due to creation of C or due to calling
some function):

C.dualComplex, the dual complex of C in the sense of dual faces of a polytope.
See dualize.

C.isPolytope, a Boolean (Macaulay2Doc), indicating whether C is a
polytope.

C.polytopalFacets, a List (Macaulay2Doc), with the boundary faces of
the polytope C.

C.complementComplex, the complement complex of C (if C is a subcocomplex of a
simplex). See complement (Macaulay2Doc).

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : C.simplexRing                                                           |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : C.grading                                                               |
|                                                                             |
|o4 = | -1 -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  0  |                                                      |
|     | 0  1  0  0  0  |                                                      |
|     | 0  0  1  0  0  |                                                      |
|     | 0  0  0  1  0  |                                                      |
|     | 0  0  0  0  1  |                                                      |
|                                                                             |
|              6       5                                                      |
|o4 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i5 : C.fc_2                                                                  |
|                                                                             |
|o5 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x }        |
|       0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5   3 4 5         |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : C.facets                                                                |
|                                                                             |
|o6 = {{}, {}, {}, {x x x , x x x , x x x , x x x , x x x , x x x , x x x ,   |
|                    0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5    |
|     ------------------------------------------------------------------------|
|     x x x }, {}, {}, {}}                                                    |
|      3 4 5                                                                  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : dC=dualize C                                                            |
|                                                                             |
|o7 = 2: v v v  v v v  v v v  v v v  v v v  v v v  v v v  v v v               |
|         0 1 2  0 1 4  0 3 4  1 2 3  1 2 5  1 4 5  2 3 4  3 4 5              |
|                                                                             |
|o7 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i8 : cC=complement C                                                         |
|                                                                             |
|o8 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         4 5 3  1 4 5  1 5 2  4 2 3  0 4 3  1 0 4  1 2 3  1 0 2              |
|                                                                             |
|o8 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i9 : dualize cC                                                              |
|                                                                             |
|o9 = 2: v v v  v v v  v v v  v v v  v v v  v v v  v v v  v v v               |
|         3 4 5  2 3 5  1 2 5  0 4 5  0 3 4  0 2 3  0 1 5  0 1 2              |
|                                                                             |
|o9 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+

Caveat
======

So far a co-complex is of class complex and the methods checks of which type it
really is. At some point both will have a common ancestor.

See also
========

  * Complex -- The class of all embedded complexes.
  * Face -- The class of all faces of complexes or co-complexes.

Methods that use an embedded co-complex:
========================================

  * "coComplexToIdeal(CoComplex)" -- see coComplexToIdeal,
    -- The monomial ideal associated to a CoComplex.

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

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

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

The source of this document is in SRdeformations.m2:6857:0.

coComplex -- Make a co-complex.
*******************************

  * Usage:
        coComplex(R,facelist)
        coComplex(R,facelist,facetlist)
        coComplex(R,facelist,Rdual)
        coComplex(R,facelist,facetlist,Rdual)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * facelist, a list (Macaulay2Doc), of the faces, sorted by
        dimension
      * facetlist, a list (Macaulay2Doc), of the facets, sorted by
        dimension
      * Rdual, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an embedded co-complex,

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

Make a co-complex from a list of faces and/or facets.

This is mostly used internally but may be occasionally useful for the end user.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : grading R                                                               |
|                                                                             |
|o3 = | -1 -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  0  |                                                      |
|     | 0  1  0  0  0  |                                                      |
|     | 0  0  1  0  0  |                                                      |
|     | 0  0  0  1  0  |                                                      |
|     | 0  0  0  0  1  |                                                      |
|                                                                             |
|              6       5                                                      |
|o3 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i4 : dC=dualize C                                                            |
|                                                                             |
|o4 = 2: v v v  v v v  v v v  v v v  v v v  v v v  v v v  v v v               |
|         0 1 2  0 1 4  0 3 4  1 2 3  1 2 5  1 4 5  2 3 4  3 4 5              |
|                                                                             |
|o4 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i5 : fdC=fc dC                                                               |
|                                                                             |
|o5 = {{}, {}, {}, {v v v , v v v , v v v , v v v , v v v , v v v , v v v ,   |
|                    0 1 2   0 1 4   0 3 4   1 2 3   1 2 5   1 4 5   2 3 4    |
|     ------------------------------------------------------------------------|
|     v v v }, {v v v v , v v v v , v v v v , v v v v , v v v v , v v v v ,   |
|      3 4 5     0 1 2 3   0 1 2 4   0 1 2 5   0 1 3 4   0 1 4 5   0 2 3 4    |
|     ------------------------------------------------------------------------|
|     v v v v , v v v v , v v v v , v v v v , v v v v , v v v v },            |
|      0 3 4 5   1 2 3 4   1 2 3 5   1 2 4 5   1 3 4 5   2 3 4 5              |
|     ------------------------------------------------------------------------|
|     {v v v v v , v v v v v , v v v v v , v v v v v , v v v v v ,            |
|       0 1 2 3 4   0 1 2 3 5   0 1 2 4 5   0 1 3 4 5   0 2 3 4 5             |
|     ------------------------------------------------------------------------|
|     v v v v v }, {v v v v v v }}                                            |
|      1 2 3 4 5     0 1 2 3 4 5                                              |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : Rdual=simplexRing dC                                                    |
|                                                                             |
|o6 = Rdual                                                                   |
|                                                                             |
|o6 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i7 : grading Rdual                                                           |
|                                                                             |
|o7 = | -1 -1 -1 -1 5  |                                                      |
|     | -1 -1 -1 5  -1 |                                                      |
|     | -1 -1 5  -1 -1 |                                                      |
|     | -1 5  -1 -1 -1 |                                                      |
|     | 5  -1 -1 -1 -1 |                                                      |
|     | -1 -1 -1 -1 -1 |                                                      |
|                                                                             |
|              6       5                                                      |
|o7 : Matrix QQ  <-- QQ                                                       |
+-----------------------------------------------------------------------------+
|i8 : dC1=coComplex(Rdual,fdC)                                                |
|                                                                             |
|o8 = 2: v v v  v v v  v v v  v v v  v v v  v v v  v v v  v v v               |
|         0 1 2  0 1 4  0 3 4  1 2 3  1 2 5  1 4 5  2 3 4  3 4 5              |
|                                                                             |
|o8 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i9 : dC==dC1                                                                 |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

If both the list of faces and facets is specified there is no consistency
check.

See also
========

  * Face -- The class of all faces of complexes or co-complexes.

Ways to use coComplex:
======================

  * "coComplex(PolynomialRing,List)"
  * "coComplex(PolynomialRing,List,List)"
  * "coComplex(PolynomialRing,List,List,PolynomialRing)"
  * "coComplex(PolynomialRing,List,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:6984:0.

coComplexToIdeal -- The monomial ideal associated to a CoComplex.
*****************************************************************

  * Usage:
        coComplexToIdeal(C)
  * Inputs:
      * C, an embedded co-complex,
  * Outputs:
      * an ideal (Macaulay2Doc),

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

The monomial ideal associated to a CoComplex, i.e., the intersection of all
ideal (Macaulay2Doc), vert, F for Face,s F
of C.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                   |
|                                                                          |
|o2 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o2 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i3 : C0=simplex(R)                                                        |
|                                                                          |
|o3 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i4 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                     |
|                                                                          |
|o4 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   3 4   0 4                                  |
|                                                                          |
|o4 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i5 : C=idealToComplex(I)                                                  |
|                                                                          |
|o5 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o5 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i6 : embeddingComplex C                                                   |
|                                                                          |
|o6 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o6 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i7 : idealToComplex(I,C0)                                                 |
|                                                                          |
|o7 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i8 : complexToIdeal(C)                                                    |
|                                                                          |
|o8 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   0 4   3 4                                  |
|                                                                          |
|o8 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i9 : cC=idealToCoComplex(I,C0)                                            |
|                                                                          |
|o9 = 2: x x x  x x x  x x x  x x x  x x x                                 |
|         0 1 3  0 2 3  0 2 4  1 2 4  1 3 4                                |
|                                                                          |
|o9 : co-complex of dim 2 embedded in dim 4 (printing facets)              |
|     equidimensional, simplicial, F-vector {0, 0, 0, 5, 5, 1}, Euler = 1  |
+--------------------------------------------------------------------------+
|i10 : cC==complement C                                                    |
|                                                                          |
|o10 = true                                                                |
+--------------------------------------------------------------------------+
|i11 : I==coComplexToIdeal(cC)                                             |
|                                                                          |
|o11 = true                                                                |
+--------------------------------------------------------------------------+
|i12 : dualize cC                                                          |
|                                                                          |
|o12 = 1: v v  v v  v v  v v  v v                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o12 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+

See also
========

  * complexToIdeal -- The monomial ideal associated to a
    complex.
  * idealToComplex -- The complex associated to a
    reduced monomial ideal.
  * idealToCoComplex -- The co-complex associated to a
    reduced monomial ideal.

Ways to use coComplexToIdeal:
=============================

  * "coComplexToIdeal(CoComplex)"

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

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

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

The source of this document is in SRdeformations.m2:6444:0.

cokerElement -- Gives an element in the cokernel of a matrix.
*************************************************************

  * Usage:
        cokerElement(v,A)
  * Inputs:
      * v, a vector (Macaulay2Doc),
      * A, a matrix (Macaulay2Doc),
  * Outputs:
      * a thing (Macaulay2Doc),

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

Gives the element in the cokernel (Macaulay2Doc), of A
represented by v. The Vector (Macaulay2Doc), v has to lie in
target (Macaulay2Doc), of A.

+--------------------------------------------------------------+
|i1 : A= matrix {{-1, -1, -1}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}|
|                                                              |
|o1 = | -1 -1 -1 |                                             |
|     | 1  0  0  |                                             |
|     | 0  1  0  |                                             |
|     | 0  0  1  |                                             |
|                                                              |
|              4       3                                       |
|o1 : Matrix ZZ  <-- ZZ                                        |
+--------------------------------------------------------------+
|i2 : c1=cokerElement(vector {1,1,0,0},A)                      |
|                                                              |
|o2 = | 2 |                                                    |
|     | 0 |                                                    |
|     | 0 |                                                    |
|     | 0 |                                                    |
|                                                              |
|o2 : Vector                                                   |
+--------------------------------------------------------------+
|i3 : c2=cokerElement(vector {1,-1,0,0},A)                     |
|                                                              |
|o3 = 0                                                        |
|                                                              |
|o3 : Vector                                                   |
+--------------------------------------------------------------+
|i4 : c2==(0_(class c2))                                       |
|                                                              |
|o4 = true                                                     |
+--------------------------------------------------------------+
|i5 : iszero c2                                                |
|                                                              |
|o5 = true                                                     |
+--------------------------------------------------------------+

See also
========

  * inducedMap (Macaulay2Doc) -- compute an induced map

Ways to use cokerElement:
=========================

  * "cokerElement(Matrix,Matrix)"
  * "cokerElement(Vector,Matrix)"

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

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

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

The source of this document is in SRdeformations.m2:4034:0.

complement(Complex) -- Compute the complement CoComplex.
********************************************************

  * Function: complement (Macaulay2Doc),
  * Usage:
        complement(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an embedded co-complex,

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

Given a Complex, it returns the CoComplex, of
complement Face,s and vice versa.

The complement (co)complex cC is remembered in C.complementComplex=cC and
cC.complementComplex=C.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i5 : cbC=complement bC                                                     |
|                                                                           |
|o5 = 0: x  x  x  x  x                                                      |
|         4  3  2  1  0                                                     |
|                                                                           |
|o5 : co-complex of dim 0 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial, F-vector {0, 5, 10, 10, 5, 1}, Euler = 1 |
+---------------------------------------------------------------------------+
|i6 : complement cbC == bC                                                  |
|                                                                           |
|o6 = true                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * complement(Face) -- Compute the complement
    face of a simplex.

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

  * complement(Complex) -- Compute the
    complement CoComplex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5445:0.

complement(Face) -- Compute the complement face of a simplex.
*************************************************************

  * Function: complement (Macaulay2Doc),
  * Usage:
        complement(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * a face,

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

Computes the complement face of a face of a simplex (or subcomples thereof).

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : C=simplex R                                                           |
|                                                                           |
|o2 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i3 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o3 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o3 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i4 : F=bC.fc_2_0                                                           |
|                                                                           |
|o4 = x x x                                                                 |
|      0 1 2                                                                |
|                                                                           |
|o4 : face with 3 vertices                                                  |
+---------------------------------------------------------------------------+
|i5 : complement F                                                          |
|                                                                           |
|o5 = x x                                                                   |
|      3 4                                                                  |
|                                                                           |
|o5 : face with 2 vertices                                                  |
+---------------------------------------------------------------------------+

See also
========

  * complement(Complex) -- Compute the
    complement CoComplex.

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

  * complement(Face) -- Compute the complement
    face of a simplex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5415:0.

complementComplex -- Optional data of Complex.
**********************************************

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

Optional data in the MutableHashTable (Macaulay2Doc),
Complex, storing the complement complex.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

The object complementComplex, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6758:0.

Complex -- The class of all embedded complexes.
***********************************************

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

The class of all embedded complexes, not necessarily simplicial or compact or
equidimensional. These are complexes with coordinates assigned to their
vertices.

Creating complexes:

The following functions return complexes:

simplex, -- Simplex in the variables of a polynomial ring

See boundaryCyclicPolytope, -- The boundary complex
of a cyclic polytope with standard projective space vertices

See fullCyclicPolytope, -- The full cyclic polytope with
moment curve vertices

See convHull, -- The convex hull

See hull, -- The positive hull

See boundaryOfPolytope, -- The boundary of a polytope

See newEmptyComplex, -- Generates an empty complex.

See idealToComplex, -- The complex associated to a reduced
monomial ideal

See dualize, -- The dual of a co-complex.

See complement (Macaulay2Doc), -- The complement of a co-complex.

See complex, -- Make a complex from a list of faces

See complexFromFacets, -- Make a complex from a list of
facets

See embeddingComplex, -- The complex containing a
subcomplex

For examples see the documentation of these functions.

The data stored in a complex C:

C.simplexRing, the polynomial ring of vertices of C.

C.grading, is C.simplexRing.grading, a matrix with the coordinates of the
vertices of C in its rows.

C.facets, a list with the facets of C sorted into lists by dimension.

C.edim, the embedding dimension of C, i.e., see rank (Macaulay2Doc),
source (Macaulay2Doc), C.grading.

C.dim, the dimension of the complex.

C.isSimp, a Boolean (Macaulay2Doc), indicating whether C is
simplicial.

C.isEquidimensional, a Boolean (Macaulay2Doc), indicating whether
C is equidimensional.

If not just the facets but the faces of C a known (e.g., after computed with
fc) then the following data is present:

C.fc, a ScriptedFunctor (Macaulay2Doc), with the faces of
C sorted and indexed by dimension.

C.fvector, a List (Macaulay2Doc), with the F-vector of C.

The following may be present (if known due to creation of C or due to calling
some function):

C.dualComplex, the dual co-complex of C in the sense of dual faces of a
polytope. See dualize.

C.isPolytope, a Boolean (Macaulay2Doc), indicating whether C is a
polytope.

C.polytopalFacets, a List (Macaulay2Doc), with the boundary faces of
the polytope C.

C.complementComplex, the complement co-complex of C (if C is a subcomplex of a
simplex). See complement (Macaulay2Doc).

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : C.simplexRing                                                           |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : C.grading                                                               |
|                                                                             |
|o4 = | -1 -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  0  |                                                      |
|     | 0  1  0  0  0  |                                                      |
|     | 0  0  1  0  0  |                                                      |
|     | 0  0  0  1  0  |                                                      |
|     | 0  0  0  0  1  |                                                      |
|                                                                             |
|              6       5                                                      |
|o4 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i5 : C.fc_2                                                                  |
|                                                                             |
|o5 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x }        |
|       0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5   3 4 5         |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : C.facets                                                                |
|                                                                             |
|o6 = {{}, {}, {}, {x x x , x x x , x x x , x x x , x x x , x x x , x x x ,   |
|                    0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5    |
|     ------------------------------------------------------------------------|
|     x x x }, {}, {}, {}}                                                    |
|      3 4 5                                                                  |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : dualize C                                                               |
|                                                                             |
|o7 = 2: v v v  v v v  v v v  v v v  v v v  v v v  v v v  v v v               |
|         0 1 2  0 1 4  0 3 4  1 2 3  1 2 5  1 4 5  2 3 4  3 4 5              |
|                                                                             |
|o7 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i8 : complement C                                                            |
|                                                                             |
|o8 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         3 4 5  1 4 5  2 1 5  2 3 4  3 0 4  1 0 4  2 3 1  2 1 0              |
|                                                                             |
|o8 : co-complex of dim 2 embedded in dim 5 (printing facets)                 |
|     equidimensional, simplicial, F-vector {0, 0, 0, 8, 12, 6, 1}, Euler = 1 |
+-----------------------------------------------------------------------------+

+-----------------------------------------------------------------------------+
|i9 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o9 = R                                                                       |
|                                                                             |
|o9 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i10 : C=simplex R                                                            |
|                                                                             |
|o10 = 5: x x x x x x                                                         |
|          0 1 2 3 4 5                                                        |
|                                                                             |
|o10 : complex of dim 5 embedded in dim 5 (printing facets)                   |
|      equidimensional, simplicial, F-vector {1, 6, 15, 20, 15, 6, 1}, Euler =|
|-----------------------------------------------------------------------------|
|0                                                                            |
+-----------------------------------------------------------------------------+
|i11 : C.isPolytope                                                           |
|                                                                             |
|o11 = true                                                                   |
+-----------------------------------------------------------------------------+
|i12 : C.polytopalFacets                                                      |
|                                                                             |
|o12 = {x x x x x , x x x x x , x x x x x , x x x x x , x x x x x ,           |
|        0 1 2 3 4   0 1 2 3 5   0 1 2 4 5   0 1 3 4 5   0 2 3 4 5            |
|      -----------------------------------------------------------------------|
|      x x x x x }                                                            |
|       1 2 3 4 5                                                             |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * CoComplex -- The class of all embedded co-complexes.
  * Face -- The class of all faces of complexes or co-complexes.
  * HH Complex -- Compute the homology of a complex.

Types of embedded complex:
==========================

  * CoComplex -- The class of all embedded co-complexes.

Methods that use an embedded complex:
=====================================

  * "addFaceDataToComplex(Complex,List)" -- see addFaceDataToComplex,
    -- Adds to a complex face data.
  * "addFaceDataToComplex(Complex,List,List)" -- see
    addFaceDataToComplex, -- Adds to a complex face data.
  * "addFacetDataToComplex(Complex,List)" -- see addFacetDataToComplex,
    -- Adds to a complex facet data.
  * "boundaryOfPolytope(Complex)" -- see boundaryOfPolytope,
    -- The boundary of a polytope.
  * "closedStar(Face,Complex)" -- see closedStar, -- The
    closed star of a face of a complex.
  * complement(Complex) -- Compute the
    complement CoComplex.
  * Complex == Complex -- Compare two complexes.
  * "complexToIdeal(Complex)" -- see complexToIdeal, --
    The monomial ideal associated to a complex.
  * "coordinates(Face,Complex)" -- see coordinates, -- The
    coordinates of a face.
  * "deform(Complex)" -- see deform, -- Compute the deformations
    associated to a Stanley-Reisner complex.
  * "deformationsFace(Face,Complex)" -- see deformationsFace,
    -- Compute the deformations associated to a face.
  * "deformationsFace(Face,Complex,Ideal)" -- see deformationsFace,
    -- Compute the deformations associated to a face.
  * dim(Complex) -- Compute the dimension of a complex
    or co-complex.
  * dim(Face,Complex) -- Compute the dimension
    of a face.
  * "dualGrading(Complex)" -- see dualGrading, -- The dual
    vertices of a polytope.
  * "dualize(Complex)" -- see dualize, -- The dual of a face or
    complex.
  * "edim(Complex)" -- see edim, -- The embedding dimension of a
    complex or co-complex.
  * "embeddingComplex(Complex)" -- see embeddingComplex,
    -- The embedding complex of a complex or co-complex.
  * "eulerCharacteristic(Complex)" -- see eulerCharacteristic,
    -- The Euler characteristic of a complex.
  * "face(List,Complex)" -- see face, -- Generate a face.
  * "face(List,Complex,ZZ,ZZ)" -- see face, -- Generate a face.
  * "facets(Complex)" -- see facets, -- The maximal faces of a
    complex.
  * "fc(Complex)" -- see fc, -- The faces of a complex.
  * "fc(Complex,ZZ)" -- see fc, -- The faces of a complex.
  * "fvector(Complex)" -- see fvector, -- The F-vector of a
    complex.
  * grading(Complex) -- The grading of a complex.
  * HH Complex -- Compute the homology of a complex.
  * "idealToCoComplex(Ideal,Complex)" -- see idealToCoComplex,
    -- The co-complex associated to a reduced monomial ideal.
  * "idealToCoComplex(MonomialIdeal,Complex)" -- see idealToCoComplex,
    -- The co-complex associated to a reduced monomial ideal.
  * "idealToComplex(Ideal,Complex)" -- see idealToComplex,
    -- The complex associated to a reduced monomial ideal.
  * "idealToComplex(MonomialIdeal,Complex)" -- see idealToComplex,
    -- The complex associated to a reduced monomial ideal.
  * "isEquidimensional(Complex)" -- see isEquidimensional,
    -- Check whether a complex or co-complex is
    equidimensional.
  * "isPolytope(Complex)" -- see isPolytope, -- Check whether
    a complex is a polytope.
  * "isSimp(Complex)" -- see isSimp, -- Check whether a complex
    or co-complex is simplicial.
  * "link(Face,Complex)" -- see link, -- The link of a face of a
    complex.
  * "loadDeformations(Complex,String)" -- see loadDeformations,
    -- Read the deformation data of a complex from a file.
  * "minimalNonFaces(Complex)" -- see minimalNonFaces,
    -- The minimal non-faces of a complex.
  * net(Complex) -- Printing complexes.
  * "polytopalFacets(Complex)" -- see polytopalFacets,
    -- The facets of a polytope.
  * "PT1(Complex)" -- see PT1, -- Compute the deformation polytope
    associated to a Stanley-Reisner complex.
  * "saveDeformations(Complex,String)" -- see saveDeformations,
    -- Store the deformation data of a complex in a file.
  * simplexRing(Complex) -- The underlying
    polynomial ring of a complex.
  * "trivialDeformations(Complex)" -- see trivialDeformations,
    -- Compute the trivial deformations.
  * "tropDef(Complex,Complex)" -- see tropDef, -- The co-complex
    of tropical faces of the deformation polytope.
  * "variables(Complex)" -- see variables, -- The variables of
    a complex or co-complex.
  * "vert(Complex)" -- see vert, -- The vertices of a face or
    complex.
  * "verticesDualPolytope(Complex)" -- see verticesDualPolytope,
    -- The dual vertices of a polytope.

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

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

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

The source of this document is in SRdeformations.m2:6728:0.

complex -- Make a complex.
**************************

  * Usage:
        complex(R,facelist)
        complex(R,facelist,facetlist)
        complex(R,facelist,Rdual)
        complex(R,facelist,facetlist,Rdual)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * facelist, a list (Macaulay2Doc), of the faces, sorted by
        dimension
      * facetlist, a list (Macaulay2Doc), of the facets, sorted by
        dimension
      * Rdual, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an embedded complex,

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

Make a complex from a list of faces and/or facets.

This is mostly used internally but may be occasionally useful for the end user.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : fC=fc C                                                                 |
|                                                                             |
|o3 = {{{}}, {x , x , x , x , x , x }, {x x , x x , x x , x x , x x , x x ,   |
|              0   1   2   3   4   5     0 1   0 2   1 2   0 3   2 3   0 4    |
|     ------------------------------------------------------------------------|
|     x x , x x , x x , x x , x x , x x }, {x x x , x x x , x x x , x x x ,   |
|      3 4   0 5   1 5   2 5   3 5   4 5     0 1 2   0 2 3   0 3 4   0 1 5    |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x }, {}, {}, {}}                            |
|      1 2 5   2 3 5   0 4 5   3 4 5                                          |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : C1=complex(R,fC)                                                        |
|                                                                             |
|o4 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o4 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i5 : C==C1                                                                   |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

If both the list of faces and facets is specified there is no consistency
check.

See also
========

  * Face -- The class of all faces of complexes or co-complexes.
  * complexFromFacets -- Make a complex from its
    facets.

Ways to use complex:
====================

  * "complex(PolynomialRing,List)"
  * "complex(PolynomialRing,List,List)"
  * "complex(PolynomialRing,List,List,PolynomialRing)"
  * "complex(PolynomialRing,List,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:6899:0.

Complex == Complex -- Compare two complexes.
********************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        C1==C2
  * Inputs:
      * C1, an embedded complex,
      * C2, an embedded complex,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether C1 and C2 are equal.

Uses the facets of C1 and C2 (as in many examples the Stanley-Reisner ideal
cannot be computed as it is too big to write down).

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                       |
+---------------------------------------------------------------------------+
|i2 : C=simplex R;                                                          |
+---------------------------------------------------------------------------+
|i3 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o3 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o3 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i4 : dbC=dualize bC                                                        |
|                                                                           |
|o4 = 0: v  v  v  v  v                                                      |
|         0  1  2  3  4                                                     |
|                                                                           |
|o4 : co-complex of dim 0 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial, F-vector {0, 5, 10, 10, 5, 1}, Euler = 1 |
+---------------------------------------------------------------------------+
|i5 : bC==dualize dbC                                                       |
|                                                                           |
|o5 = true                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * Face == Face -- Compare two faces.
  * Complex -- The class of all embedded complexes.
  * dualize -- The dual of a face or complex.
  * facets -- The maximal faces of a complex.

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

  * Complex == Complex -- Compare two complexes.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5640:0.

complexFromFacets -- Make a complex from its facets.
****************************************************

  * Usage:
        complexFromFacets(R,facetlist)
        complexFromFacets(R,facetlist,Rdual)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * facetlist, a list (Macaulay2Doc), of the facets, sorted by
        dimension
      * Rdual, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an embedded complex,

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

Make a complex from a list of faces and/or facets.

This is mostly used internally but may be occasionally useful for the end user.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : fC=facets C                                                             |
|                                                                             |
|o3 = {{}, {}, {}, {x x x , x x x , x x x , x x x , x x x , x x x , x x x ,   |
|                    0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5    |
|     ------------------------------------------------------------------------|
|     x x x }, {}, {}, {}}                                                    |
|      3 4 5                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : C1=complexFromFacets(R,fC)                                              |
|                                                                             |
|o4 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o4 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial                                             |
+-----------------------------------------------------------------------------+
|i5 : C1==C                                                                   |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+
|i6 : fc C1;                                                                  |
+-----------------------------------------------------------------------------+
|i7 : C1                                                                      |
|                                                                             |
|o7 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o7 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+

Caveat
======

If both the list of faces and facets is specified there is no consistency
check.

See also
========

  * Face -- The class of all faces of complexes or co-complexes.
  * complex -- Make a complex.
  * fc -- The faces of a complex.

Ways to use complexFromFacets:
==============================

  * "complexFromFacets(PolynomialRing,List)"
  * "complexFromFacets(PolynomialRing,List,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:6938:0.

complexToIdeal -- The monomial ideal associated to a complex.
*************************************************************

  * Usage:
        complexToIdeal(C)
  * Inputs:
      * C, an embedded complex,
  * Optional inputs (Macaulay2Doc),:
      * embedded, => ..., default value null, Use only faces of
        the embedding complex.
  * Outputs:
      * an ideal (Macaulay2Doc),

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

The Stanley-Reisner ideal associated to a complex, i.e., the ideal of non-faces
of C.

If the option embedded=>true is given, then only Face,s of
embeddingComplex, C are used.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                   |
|                                                                          |
|o2 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o2 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i3 : C0=simplex(R)                                                        |
|                                                                          |
|o3 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i4 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                     |
|                                                                          |
|o4 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   3 4   0 4                                  |
|                                                                          |
|o4 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i5 : C=idealToComplex(I)                                                  |
|                                                                          |
|o5 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o5 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i6 : embeddingComplex C                                                   |
|                                                                          |
|o6 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o6 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i7 : idealToComplex(I,C0)                                                 |
|                                                                          |
|o7 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i8 : complexToIdeal(C)                                                    |
|                                                                          |
|o8 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   0 4   3 4                                  |
|                                                                          |
|o8 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i9 : cC=idealToCoComplex(I,C0)                                            |
|                                                                          |
|o9 = 2: x x x  x x x  x x x  x x x  x x x                                 |
|         0 1 3  0 2 3  0 2 4  1 2 4  1 3 4                                |
|                                                                          |
|o9 : co-complex of dim 2 embedded in dim 4 (printing facets)              |
|     equidimensional, simplicial, F-vector {0, 0, 0, 5, 5, 1}, Euler = 1  |
+--------------------------------------------------------------------------+
|i10 : cC==complement C                                                    |
|                                                                          |
|o10 = true                                                                |
+--------------------------------------------------------------------------+
|i11 : I==coComplexToIdeal(cC)                                             |
|                                                                          |
|o11 = true                                                                |
+--------------------------------------------------------------------------+
|i12 : dualize cC                                                          |
|                                                                          |
|o12 = 1: v v  v v  v v  v v  v v                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o12 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+

See also
========

  * coComplexToIdeal -- The monomial ideal associated
    to a CoComplex.
  * idealToComplex -- The complex associated to a
    reduced monomial ideal.
  * idealToCoComplex -- The co-complex associated to a
    reduced monomial ideal.
  * embeddingComplex -- The embedding complex of a
    complex or co-complex.

Ways to use complexToIdeal:
===========================

  * "complexToIdeal(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6504:0.

computeFaces -- Compute faces of a simplex.
*******************************************

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

Determines whether all faces of a simplex are being computed.

+---------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                      |
|                                                         |
|o1 = R                                                   |
|                                                         |
|o1 : PolynomialRing                                      |
+---------------------------------------------------------+
|i2 : simplex(R,computeFaces=>false)                      |
|                                                         |
|o2 = 4: x x x x x                                        |
|         0 1 2 3 4                                       |
|                                                         |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)|
|     equidimensional, simplicial                         |
+---------------------------------------------------------+

See also
========

  * simplex -- Simplex in the variables of a polynomial ring.

Functions with optional argument named computeFaces:
====================================================

  * "simplex(...,computeFaces=>...)"

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

The object computeFaces, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6078:0.

convHull -- The convex hull complex.
************************************

  * Usage:
        convHull(L)
        convHull(fn)
  * Inputs:
      * L, a list (Macaulay2Doc), of Vector (Macaulay2Doc),
        s
      * fn, a string (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * file, => ..., default value null, Store result of a
        computation in a file.
  * Outputs:
      * C, an embedded complex,

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

Returns the convex hull of lattice vectors lying all in the same space. The
output has C.isPolytope==true.

If applied to the string fn the result of a previous computation stored via the
option file, is read from the file fn.

The 0-point has to lie in the convex hull.

+-----------------------------------------------------------------------------+
|i1 : L={vector {1,0,0},vector {-1,0,0},vector {0,1,0},vector {0,-1,0},vector |
|                                                                             |
|o1 = {| 1 |, | -1 |, | 0 |, |  0 |, | 0 |, |  0 |}                           |
|      | 0 |  |  0 |  | 1 |  | -1 |  | 0 |  |  0 |                            |
|      | 0 |  |  0 |  | 0 |  |  0 |  | 1 |  | -1 |                            |
|                                                                             |
|o1 : List                                                                    |
|-----------------------------------------------------------------------------|
|{0,0,1},vector {0,0,-1}}                                                     |
+-----------------------------------------------------------------------------+
|i2 : P=convHull(L)                                                           |
|                                                                             |
|o2 = 3: y y y y y y                                                          |
|         0 1 2 3 4 5                                                         |
|                                                                             |
|o2 : complex of dim 3 embedded in dim 3 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0   |
+-----------------------------------------------------------------------------+
|i3 : dP=boundaryOfPolytope P                                                 |
|                                                                             |
|o3 = 2: y y y  y y y  y y y  y y y  y y y  y y y  y y y  y y y               |
|         0 2 4  1 2 4  0 3 4  1 3 4  0 2 5  1 2 5  0 3 5  1 3 5              |
|                                                                             |
|o3 : complex of dim 2 embedded in dim 3 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0}, Euler = 1       |
+-----------------------------------------------------------------------------+

Caveat
======

This uses the package Polyhedra to compute the facets. Too slow compared to
Maple/convex.

If the package ConvexInterface is loaded, then this command calls Maple/Convex.
See the corresponding option explained at SRdeformations.

See also
========

  * Complex -- The class of all embedded complexes.

Ways to use convHull:
=====================

  * "convHull(List)"
  * "convHull(String)"

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

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

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

The source of this document is in SRdeformations.m2:6226:0.

coordinates -- The coordinates of a face.
*****************************************

  * Usage:
        coordinates(C)
  * Inputs:
      * F, a face,
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the coordinates of a face if some coker graded ring can be associated
to F (if there is non one can give the second argument C).

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i5 : F=bC.fc_2_0                                                           |
|                                                                           |
|o5 = x x x                                                                 |
|      0 1 2                                                                |
|                                                                           |
|o5 : face with 3 vertices                                                  |
+---------------------------------------------------------------------------+
|i6 : coordinates F                                                         |
|                                                                           |
|o6 = {{-1, -1, -1, -1}, {1, 0, 0, 0}, {0, 1, 0, 0}}                        |
|                                                                           |
|o6 : List                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use coordinates:
========================

  * "coordinates(Face)"
  * "coordinates(Face,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:5474:0.

deform -- Compute the deformations associated to a Stanley-Reisner complex.
***************************************************************************

  * Usage:
        deform(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a list (Macaulay2Doc),

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

Compute a list with the homogeneous (i.e., see degree(FirstOrderDeformation),
zero) deformations associated to
Stanley-Reisner complex C.

The result of the computation is stored in the key C.deform and this data can
be stored to and loaded from a file by saveDeformations,
and loadDeformations.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                        |
|                                                                             |
|o2 = ideal (x x , x x , x x , x x , x x )                                    |
|             0 1   1 2   2 3   3 4   0 4                                     |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : C1=idealToComplex I                                                     |
|                                                                             |
|o3 = 1: x x  x x  x x  x x  x x                                              |
|         0 2  0 3  1 3  1 4  2 4                                             |
|                                                                             |
|o3 : complex of dim 1 embedded in dim 4 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1    |
+-----------------------------------------------------------------------------+
|i4 : deform C1                                                               |
|                                                                             |
|                2             2             2             2             2    |
|      x   x    x    x   x    x    x   x    x    x   x    x    x   x    x     |
|       0   0    0    1   1    1    2   2    2    3   3    3    4   4    4    |
|o4 = {--, --, ----, --, --, ----, --, --, ----, --, --, ----, --, --, ----,  |
|      x   x   x x   x   x   x x   x   x   x x   x   x   x x   x   x   x x    |
|       3   2   2 3   4   3   3 4   4   0   0 4   1   0   0 1   2   1   1 2   |
|     ------------------------------------------------------------------------|
|     x   x   x   x   x   x   x   x   x   x                                   |
|      1   4   0   2   1   3   2   4   0   3                                  |
|     --, --, --, --, --, --, --, --, --, --}                                 |
|     x   x   x   x   x   x   x   x   x   x                                   |
|      0   0   1   1   2   2   3   3   4   4                                  |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

To homogenize the denominators of deformations (which are supported inside the
link) we use globalSections to deal with the toric case. Speed of this should
be improved. For ordinary projective space globalSections works much faster.

See also
========

  * deformationsFace -- Compute the deformations
    associated to a face.
  * loadDeformations -- Read the deformation data of a
    complex from a file.
  * saveDeformations -- Store the deformation data of
    a complex in a file.
  * link -- The link of a face of a complex.
  * globalSections -- The global sections of a toric
    divisor.

Ways to use deform:
===================

  * "deform(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7441:0.

deformationsFace -- Compute the deformations associated to a face.
******************************************************************

  * Usage:
        deformationsFace(F,C)
        deformationsFace(F,C,I)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
      * I, an ideal (Macaulay2Doc), reduced monomial
  * Outputs:
      * a list (Macaulay2Doc),

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

Compute the homogeneous (i.e., see degree(FirstOrderDeformation),
zero) deformations associated to a face F of
the complex C.

The additional parameter I should be the Stanley-Reisner ideal of C and can be
given to avoid computation of the Stanley-Reisner ideal if it is already known.
Usually this is not necessary: Once I is computed it is stored in C.ideal, so
deformationsFace(F,C,I) is equivalent to deformationsFace(F,C). Note also that
all methods producing a complex from an ideal (like idealToComplex)
store the ideal in C.ideal.

The deformations and C are stored in F.deform = {C, deformations}. Note that
usually C is not ofComplex F.

+------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                     |
|                                                                        |
|o1 = R                                                                  |
|                                                                        |
|o1 : PolynomialRing                                                     |
+------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1*x_2,x_3*x_4)                                       |
|                                                                        |
|o2 = ideal (x x x , x x )                                               |
|             0 1 2   3 4                                                |
|                                                                        |
|o2 : Ideal of R                                                         |
+------------------------------------------------------------------------+
|i3 : C1=idealToComplex I                                                |
|                                                                        |
|o3 = 2: x x x  x x x  x x x  x x x  x x x  x x x                        |
|         0 1 3  0 2 3  1 2 3  0 1 4  0 2 4  1 2 4                       |
|                                                                        |
|o3 : complex of dim 2 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial, F-vector {1, 5, 9, 6, 0, 0}, Euler = 1|
+------------------------------------------------------------------------+
|i4 : F=C1.fc_0_0                                                        |
|                                                                        |
|o4 = x                                                                  |
|      0                                                                 |
|                                                                        |
|o4 : face with 1 vertex                                                 |
+------------------------------------------------------------------------+
|i5 : deformationsFace(F,C1)                                             |
|                                                                        |
|                        2     2                                         |
|      x   x   x   x    x     x                                          |
|       0   0   0   0    0     0                                         |
|o5 = {--, --, --, --, ----, ----}                                       |
|      x   x   x   x   x x   x x                                         |
|       4   3   2   1   3 4   1 2                                        |
|                                                                        |
|o5 : List                                                               |
+------------------------------------------------------------------------+
|i6 : F=C1.fc_0_1                                                        |
|                                                                        |
|o6 = x                                                                  |
|      1                                                                 |
|                                                                        |
|o6 : face with 1 vertex                                                 |
+------------------------------------------------------------------------+
|i7 : deformationsFace(F,C1)                                             |
|                                                                        |
|                        2     2                                         |
|      x   x   x   x    x     x                                          |
|       1   1   1   1    1     1                                         |
|o7 = {--, --, --, --, ----, ----}                                       |
|      x   x   x   x   x x   x x                                         |
|       4   3   2   0   3 4   0 2                                        |
|                                                                        |
|o7 : List                                                               |
+------------------------------------------------------------------------+
|i8 : F=C1.fc_1_0                                                        |
|                                                                        |
|o8 = x x                                                                |
|      0 1                                                               |
|                                                                        |
|o8 : face with 2 vertices                                               |
+------------------------------------------------------------------------+
|i9 : deformationsFace(F,C1)                                             |
|                                                                        |
|      x x                                                               |
|       0 1                                                              |
|o9 = {----}                                                             |
|      x x                                                               |
|       3 4                                                              |
|                                                                        |
|o9 : List                                                               |
+------------------------------------------------------------------------+
|i10 : F=C1.fc_2_0                                                       |
|                                                                        |
|o10 = x x x                                                             |
|       0 1 3                                                            |
|                                                                        |
|o10 : face with 3 vertices                                              |
+------------------------------------------------------------------------+
|i11 : deformationsFace(F,C1)                                            |
|                                                                        |
|o11 = {}                                                                |
|                                                                        |
|o11 : List                                                              |
+------------------------------------------------------------------------+

+--------------------------------------------------------------------------+
|i12 : R=QQ[x_0..x_4]                                                      |
|                                                                          |
|o12 = R                                                                   |
|                                                                          |
|o12 : PolynomialRing                                                      |
+--------------------------------------------------------------------------+
|i13 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                          |
|o13 = ideal (x x , x x , x x , x x , x x )                                |
|              0 1   1 2   2 3   3 4   0 4                                 |
|                                                                          |
|o13 : Ideal of R                                                          |
+--------------------------------------------------------------------------+
|i14 : C1=idealToComplex I                                                 |
|                                                                          |
|o14 = 1: x x  x x  x x  x x  x x                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o14 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+
|i15 : F=C1.fc_0_1                                                         |
|                                                                          |
|o15 = x                                                                   |
|       1                                                                  |
|                                                                          |
|o15 : face with 1 vertex                                                  |
+--------------------------------------------------------------------------+
|i16 : deformationsFace(F,C1)                                              |
|                                                                          |
|                 2                                                        |
|       x   x    x                                                         |
|        1   1    1                                                        |
|o16 = {--, --, ----}                                                      |
|       x   x   x x                                                        |
|        4   3   3 4                                                       |
|                                                                          |
|o16 : List                                                                |
+--------------------------------------------------------------------------+
|i17 : F=C1.fc_1_1                                                         |
|                                                                          |
|o17 = x x                                                                 |
|       0 3                                                                |
|                                                                          |
|o17 : face with 2 vertices                                                |
+--------------------------------------------------------------------------+
|i18 : deformationsFace(F,C1)                                              |
|                                                                          |
|o18 = {}                                                                  |
|                                                                          |
|o18 : List                                                                |
+--------------------------------------------------------------------------+

Caveat
======

To homogenize the denominators of deformations (which are supported inside the
link) we use globalSections to deal with the toric case. Speed of this should
be improved. For ordinary projective space globalSections works much faster.

See also
========

  * deform -- Compute the deformations associated to a
    Stanley-Reisner complex.
  * link -- The link of a face of a complex.
  * globalSections -- The global sections of a toric
    divisor.

Ways to use deformationsFace:
=============================

  * "deformationsFace(Face,Complex)"
  * "deformationsFace(Face,Complex,Ideal)"

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

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

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

The source of this document is in SRdeformations.m2:7400:0.

degree(FirstOrderDeformation) -- The small torus degree of a deformation.
*************************************************************************

  * Function: degree (Macaulay2Doc),
  * Usage:
        degree(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a thing (Macaulay2Doc),

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

Computes the small torus degree (i.e., with respect to the grading added to R =
See simplexRing, f by addCokerGrading)
of f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : degree f                                         |
|                                                      |
|o6 = 0                                                |
|                                                      |
|o6 : Vector                                           |
+------------------------------------------------------+

See also
========

  * grading -- The grading of a first order deformation or
    complex or polynomial ring.
  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.
  * firstOrderDeformation -- Makes a first order
    deformation.

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

  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4588:0.

denominator(FirstOrderDeformation) -- The denominator of a deformation as a vector.
***********************************************************************************

  * Function: denominator (Macaulay2Doc),
  * Usage:
        denominator(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a vector (Macaulay2Doc),

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

Returns the denominator of a deformation as a vector.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : denominator f                                    |
|                                                      |
|o6 = | 1 |                                            |
|     | 1 |                                            |
|     | 0 |                                            |
|     | 0 |                                            |
|     | 0 |                                            |
|                                                      |
|       5                                              |
|o6 : ZZ                                               |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * numeratorMonomial -- The numerator monomial of a
    deformation.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4490:0.

denominatorMonomial -- The denominator monomial of a deformation.
*****************************************************************

  * Usage:
        denominatorMonomial(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a ring element (Macaulay2Doc),

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

Returns the denominator monomial of a deformation.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : denominatorMonomial f                            |
|                                                      |
|o6 = x x                                              |
|      0 1                                             |
|                                                      |
|o6 : R                                                |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * numeratorMonomial -- The numerator monomial of a
    deformation.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use denominatorMonomial:
================================

  * "denominatorMonomial(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4558:0.

dim(Complex) -- Compute the dimension of a complex or co-complex.
*****************************************************************

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an integer (Macaulay2Doc), bigger or equal to -1

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

Computes the dimension of a complex.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : dim C                                                                 |
|                                                                           |
|o4 = 4                                                                     |
+---------------------------------------------------------------------------+
|i5 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o5 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o5 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i6 : dim bC                                                                |
|                                                                           |
|o6 = 3                                                                     |
+---------------------------------------------------------------------------+
|i7 : dbC=dualize bC                                                        |
|                                                                           |
|o7 = 0: v  v  v  v  v                                                      |
|         0  1  2  3  4                                                     |
|                                                                           |
|o7 : co-complex of dim 0 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial, F-vector {0, 5, 10, 10, 5, 1}, Euler = 1 |
+---------------------------------------------------------------------------+
|i8 : dim dbC                                                               |
|                                                                           |
|o8 = 0                                                                     |
+---------------------------------------------------------------------------+

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

  * dim(Complex) -- Compute the dimension of a complex
    or co-complex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5269:0.

dim(Face) -- Compute the dimension of a face.
*********************************************

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * an integer (Macaulay2Doc), bigger or equal to -1

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

Computes the dimension of a face. If F.indices is present (usually the case by
construction) this requires no computations.

If F.indices is not present but a polynomial ring R can be associated to F
(which is the case if F.ofComplex is present (or given as a second argument) or
F is non-empty) then R.grading (which can be installed by
addCokerGrading) is used to compute the dimension of the
plane spanned by F.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i5 : F=bC.fc_2_0                                                           |
|                                                                           |
|o5 = x x x                                                                 |
|      0 1 2                                                                |
|                                                                           |
|o5 : face with 3 vertices                                                  |
+---------------------------------------------------------------------------+
|i6 : dim(face vert F,R)                                                    |
|                                                                           |
|o6 = 2                                                                     |
+---------------------------------------------------------------------------+

Caveat
======

If F.indices is not present this returns a dimension as explained above but
note that this does not check whether F is a face of the convex hull of the
rows of R.grading.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

  * dim(Face) -- Compute the dimension of a face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5308:0.

dim(Face,Complex) -- Compute the dimension of a face.
*****************************************************

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(F,C)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
  * Outputs:
      * an integer (Macaulay2Doc), bigger or equal to -1

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

Computes the dimension of a face. If F.indices is present (usually the case by
construction) this requires no computations.

If F.indices is not present but a polynomial ring R can be associated to F
(which is the case if F.ofComplex is present (or given as a second argument) or
F is non-empty) then R.grading (which can be installed by
addCokerGrading) is used to compute the dimension of the
plane spanned by F.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i5 : F=bC.fc_2_0                                                           |
|                                                                           |
|o5 = x x x                                                                 |
|      0 1 2                                                                |
|                                                                           |
|o5 : face with 3 vertices                                                  |
+---------------------------------------------------------------------------+
|i6 : dim(face vert F,C)                                                    |
|                                                                           |
|o6 = 2                                                                     |
+---------------------------------------------------------------------------+

Caveat
======

If F.indices is not present this returns a dimension as explained above but
note that this does not check whether F is a face of the convex hull of the
rows of R.grading.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

  * dim(Face,Complex) -- Compute the dimension
    of a face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5347:0.

dim(Face,PolynomialRing) -- Compute the dimension of a face.
************************************************************

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(F,R)
  * Inputs:
      * F, a face,
      * R, a polynomial ring (Macaulay2Doc), with coker
        grading.
  * Outputs:
      * an integer (Macaulay2Doc), bigger or equal to -1

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

Computes the dimension of a face. If F.indices is present (usually the case by
construction) this requires no computations.

If F.indices is not present but a polynomial ring R can be associated to F
(which is the case if F.ofComplex is present (or given as a second argument) or
F is non-empty) then R.grading (which can be installed by
addCokerGrading) is used to compute the dimension of the
plane spanned by F.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i5 : F=bC.fc_2_0                                                           |
|                                                                           |
|o5 = x x x                                                                 |
|      0 1 2                                                                |
|                                                                           |
|o5 : face with 3 vertices                                                  |
+---------------------------------------------------------------------------+
|i6 : dim F                                                                 |
|                                                                           |
|o6 = 2                                                                     |
+---------------------------------------------------------------------------+

Caveat
======

If F.indices is not present this returns a dimension as explained above but
note that this does not check whether F is a face of the convex hull of the
rows of R.grading.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

  * dim(Face,PolynomialRing) -- Compute
    the dimension of a face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5389:0.

dim(FirstOrderDeformation) -- Compute the dimension of a deformation.
*********************************************************************

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * an integer (Macaulay2Doc), non-negative

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

Computes the dimension of the big torus degree f part of the deformation space
of source(FirstOrderDeformation), f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : dim f                                            |
|                                                      |
|o6 = 1                                                |
+------------------------------------------------------+

See also
========

  * relationsCoefficients -- Relations between
    the coefficients of a deformation.
  * parameters -- Parameters of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4718:0.

dualComplex -- Optional data of Complex.
****************************************

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

Optional data in the MutableHashTable (Macaulay2Doc),
Complex, storing the dual complex.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

The object dualComplex, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6772:0.

dualFace -- Optional data of Face.
**********************************

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

Optional data in the MutableHashTable (Macaulay2Doc),
Face, storing the dual face.

See also
========

  * dualize -- The dual of a face or complex.

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

The object dualFace, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6785:0.

dualGrading -- The dual vertices of a polytope.
***********************************************

  * Usage:
        dualGrading(C)
  * Inputs:
      * C, an embedded complex, a polytope
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns the dual grading of (i.e., a matrix whose row are) the dual polytope of
C. The rows are sorted according to the polytopalFacets,
of C.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : C=simplex(R)                                                         |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : grading C                                                            |
|                                                                          |
|o3 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o3 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i4 : dA=dualGrading C                                                     |
|                                                                          |
|o4 = | -1 -1 -1 4  |                                                      |
|     | -1 -1 4  -1 |                                                      |
|     | -1 4  -1 -1 |                                                      |
|     | 4  -1 -1 -1 |                                                      |
|     | -1 -1 -1 -1 |                                                      |
|                                                                          |
|              5       4                                                   |
|o4 : Matrix QQ  <-- QQ                                                    |
+--------------------------------------------------------------------------+
|i5 : dA===grading dualize C                                               |
|                                                                          |
|o5 = true                                                                 |
+--------------------------------------------------------------------------+
|i6 : dA===C.dualComplex.simplexRing.grading                               |
|                                                                          |
|o6 = true                                                                 |
+--------------------------------------------------------------------------+
|i7 : pf=polytopalFacets C                                                 |
|                                                                          |
|o7 = {x x x x , x x x x , x x x x , x x x x , x x x x }                   |
|       0 1 2 3   0 1 2 4   0 1 3 4   0 2 3 4   1 2 3 4                    |
|                                                                          |
|o7 : List                                                                 |
+--------------------------------------------------------------------------+
|i8 : coordinates pf#0                                                     |
|                                                                          |
|o8 = {{-1, -1, -1, -1}, {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}}         |
|                                                                          |
|o8 : List                                                                 |
+--------------------------------------------------------------------------+
|i9 : (dualGrading C)^{0}                                                  |
|                                                                          |
|o9 = | -1 -1 -1 4 |                                                       |
|                                                                          |
|              1       4                                                   |
|o9 : Matrix QQ  <-- QQ                                                    |
+--------------------------------------------------------------------------+

Caveat
======

This just returns C.dualComplex.grading. If this data has not been computed use
verticesDualPolytope. Integrate into this
verticesDualPolytope.

See also
========

  * verticesDualPolytope -- The dual vertices of a
    polytope.
  * grading -- The grading of a first order deformation or
    complex or polynomial ring.
  * polytopalFacets -- The facets of a polytope.
  * dualize -- The dual of a face or complex.
  * isPolytope -- Check whether a complex is a polytope.
  * facets -- The maximal faces of a complex.

Ways to use dualGrading:
========================

  * "dualGrading(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6027:0.

dualize -- The dual of a face or complex.
*****************************************

  * Usage:
        dualize(F)
        dualize(C)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
      * C, an embedded co-complex,
  * Outputs:
      * an embedded co-complex,

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

Returns the dual of a face or a (co)complex. This is in the sense of dual face
of Polytopes, so the faces of C have to be faces of a polytope.

The dual (co)complex dC is stored in C.dualComplex=dC and dC.dualComplex=C.

Note that if C is a Stanley-Reisner subcomplex of a simplex then dualize
complement C is the isomorphic geometric complex of strata.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                         |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                      |
|                                                                            |
|o2 = | -1 -1 -1 -1 |                                                        |
|     | 1  0  0  0  |                                                        |
|     | 0  1  0  0  |                                                        |
|     | 0  0  1  0  |                                                        |
|     | 0  0  0  1  |                                                        |
|                                                                            |
|              5       4                                                     |
|o2 : Matrix ZZ  <-- ZZ                                                      |
+----------------------------------------------------------------------------+
|i3 : C=simplex R                                                            |
|                                                                            |
|o3 = 4: x x x x x                                                           |
|         0 1 2 3 4                                                          |
|                                                                            |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0  |
+----------------------------------------------------------------------------+
|i4 : bC=boundaryOfPolytope C                                                |
|                                                                            |
|o4 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                         |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                        |
|                                                                            |
|o4 : complex of dim 3 embedded in dim 4 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1 |
+----------------------------------------------------------------------------+
|i5 : F=bC.fc_2_0                                                            |
|                                                                            |
|o5 = x x x                                                                  |
|      0 1 2                                                                 |
|                                                                            |
|o5 : face with 3 vertices                                                   |
+----------------------------------------------------------------------------+
|i6 : coordinates F                                                          |
|                                                                            |
|o6 = {{-1, -1, -1, -1}, {1, 0, 0, 0}, {0, 1, 0, 0}}                         |
|                                                                            |
|o6 : List                                                                   |
+----------------------------------------------------------------------------+
|i7 : dualize F                                                              |
|                                                                            |
|o7 = v v                                                                    |
|      0 1                                                                   |
|                                                                            |
|o7 : face with 2 vertices                                                   |
+----------------------------------------------------------------------------+
|i8 : coordinates dualize F                                                  |
|                                                                            |
|o8 = {{-1, -1, -1, 4}, {-1, -1, 4, -1}}                                     |
|                                                                            |
|o8 : List                                                                   |
+----------------------------------------------------------------------------+
|i9 : dbC=dualize bC                                                         |
|                                                                            |
|o9 = 0: v  v  v  v  v                                                       |
|         0  1  2  3  4                                                      |
|                                                                            |
|o9 : co-complex of dim 0 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {0, 5, 10, 10, 5, 1}, Euler = 1  |
+----------------------------------------------------------------------------+
|i10 : complement F                                                          |
|                                                                            |
|o10 = x x                                                                   |
|       3 4                                                                  |
|                                                                            |
|o10 : face with 2 vertices                                                  |
+----------------------------------------------------------------------------+
|i11 : coordinates complement F                                              |
|                                                                            |
|o11 = {{0, 0, 1, 0}, {0, 0, 0, 1}}                                          |
|                                                                            |
|o11 : List                                                                  |
+----------------------------------------------------------------------------+
|i12 : complement bC                                                         |
|                                                                            |
|o12 = 0: x  x  x  x  x                                                      |
|          4  3  2  1  0                                                     |
|                                                                            |
|o12 : co-complex of dim 0 embedded in dim 4 (printing facets)               |
|      equidimensional, simplicial, F-vector {0, 5, 10, 10, 5, 1}, Euler = 1 |
+----------------------------------------------------------------------------+
|i13 : dualize complement bC                                                 |
|                                                                            |
|o13 = 3: v v v v  v v v v  v v v v  v v v v  v v v v                        |
|          1 2 3 4  0 2 3 4  0 1 3 4  0 1 2 4  0 1 2 3                       |
|                                                                            |
|o13 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|      equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+----------------------------------------------------------------------------+
|i14 : bC                                                                    |
|                                                                            |
|o14 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|          0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                            |
|o14 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|      equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+----------------------------------------------------------------------------+
|i15 : coordinates dualize complement F                                      |
|                                                                            |
|o15 = {{-1, 4, -1, -1}, {4, -1, -1, -1}, {-1, -1, -1, -1}}                  |
|                                                                            |
|o15 : List                                                                  |
+----------------------------------------------------------------------------+
|i16 : coordinates F                                                         |
|                                                                            |
|o16 = {{-1, -1, -1, -1}, {1, 0, 0, 0}, {0, 1, 0, 0}}                        |
|                                                                            |
|o16 : List                                                                  |
+----------------------------------------------------------------------------+

See also
========

  * complement(Face) -- Compute the complement
    face of a simplex.
  * complement(Complex) -- Compute the
    complement CoComplex.

Ways to use dualize:
====================

  * "dualize(Complex)"
  * "dualize(Face)"

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

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

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

The source of this document is in SRdeformations.m2:5522:0.

edim -- The embedding dimension of a complex or co-complex.
***********************************************************

  * Usage:
        edim(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an integer (Macaulay2Doc),

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

The embedding dimension of a complex or co-complex.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                         |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                          |
|                                                                            |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x              |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5             |
|                                                                            |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1|
+----------------------------------------------------------------------------+
|i3 : dim C                                                                  |
|                                                                            |
|o3 = 2                                                                      |
+----------------------------------------------------------------------------+
|i4 : edim C                                                                 |
|                                                                            |
|o4 = 5                                                                      |
+----------------------------------------------------------------------------+

See also
========

  * dim(Complex) -- Compute the dimension of a complex
    or co-complex.

Ways to use edim:
=================

  * "edim(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7038:0.

embedded -- Use only faces of the embedding complex.
****************************************************

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

If the option embedded=>true is given, then only Face,s of
embeddingComplex, C are used.

See also
========

  * complexToIdeal -- The monomial ideal associated to a
    complex.
  * minimalNonFaces -- The minimal non-faces of a
    complex.
  * coComplexToIdeal -- The monomial ideal associated
    to a CoComplex.
  * idealToComplex -- The complex associated to a
    reduced monomial ideal.
  * idealToCoComplex -- The co-complex associated to a
    reduced monomial ideal.
  * embeddingComplex -- The embedding complex of a
    complex or co-complex.

Functions with optional argument named embedded:
================================================

  * "complexToIdeal(...,embedded=>...)"
  * "minimalNonFaces(...,embedded=>...)"

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

The object embedded, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6464:0.

embeddingComplex -- The embedding complex of a complex or co-complex.
*********************************************************************

  * Usage:
        embeddingComplex(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

The embedding complex of a complex or co-complex.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                   |
|                                                                          |
|o2 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o2 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i3 : C0=simplex(R)                                                        |
|                                                                          |
|o3 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i4 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                     |
|                                                                          |
|o4 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   3 4   0 4                                  |
|                                                                          |
|o4 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i5 : C=idealToComplex(I)                                                  |
|                                                                          |
|o5 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o5 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i6 : embeddingComplex C                                                   |
|                                                                          |
|o6 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o6 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i7 : idealToComplex(I,C0)                                                 |
|                                                                          |
|o7 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i8 : complexToIdeal(C)                                                    |
|                                                                          |
|o8 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   0 4   3 4                                  |
|                                                                          |
|o8 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i9 : cC=idealToCoComplex(I,C0)                                            |
|                                                                          |
|o9 = 2: x x x  x x x  x x x  x x x  x x x                                 |
|         0 1 3  0 2 3  0 2 4  1 2 4  1 3 4                                |
|                                                                          |
|o9 : co-complex of dim 2 embedded in dim 4 (printing facets)              |
|     equidimensional, simplicial, F-vector {0, 0, 0, 5, 5, 1}, Euler = 1  |
+--------------------------------------------------------------------------+
|i10 : cC==complement C                                                    |
|                                                                          |
|o10 = true                                                                |
+--------------------------------------------------------------------------+
|i11 : I==coComplexToIdeal(cC)                                             |
|                                                                          |
|o11 = true                                                                |
+--------------------------------------------------------------------------+
|i12 : dualize cC                                                          |
|                                                                          |
|o12 = 1: v v  v v  v v  v v  v v                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o12 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+

See also
========

  * complexToIdeal -- The monomial ideal associated to a
    complex.

Ways to use embeddingComplex:
=============================

  * "embeddingComplex(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6628:0.

eulerCharacteristic -- The Euler characteristic of a complex.
*************************************************************

  * Usage:
        eulerCharacteristic(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an integer (Macaulay2Doc),

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

The Euler characteristic of C. This is printed always when printing a complex
and the faces are known.

+-------------------------------+
|i1 : R=QQ[x_0..x_5];           |
+-------------------------------+
|i2 : C=fullCyclicPolytope(3,R);|
+-------------------------------+
|i3 : fvector C                 |
|                               |
|o3 = {1, 6, 12, 8, 1}          |
|                               |
|o3 : List                      |
+-------------------------------+
|i4 : eulerCharacteristic C     |
|                               |
|o4 = 0                         |
+-------------------------------+
|i5 : dC=boundaryOfPolytope(C); |
+-------------------------------+
|i6 : fvector dC                |
|                               |
|o6 = {1, 6, 12, 8, 0}          |
|                               |
|o6 : List                      |
+-------------------------------+
|i7 : eulerCharacteristic dC    |
|                               |
|o7 = 1                         |
+-------------------------------+

See also
========

  * fvector -- The F-vector of a complex.
  * fc -- The faces of a complex.

Ways to use eulerCharacteristic:
================================

  * "eulerCharacteristic(Complex)"
  * "eulerCharacteristic(List)"

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

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

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

The source of this document is in SRdeformations.m2:6339:0.

Example first order deformation -- Example accessing the data stored in a first order deformation.
**************************************************************************************************

Example for accessing the data stored in a first order deformation:

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R)                               |
|                                                      |
|o2 = | -1 -1 -1 -1 |                                  |
|     | 1  0  0  0  |                                  |
|     | 0  1  0  0  |                                  |
|     | 0  0  1  0  |                                  |
|     | 0  0  0  1  |                                  |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : f.gens                                           |
|                                                      |
|o6 = | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |           |
|                                                      |
|             1      5                                 |
|o6 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i7 : f.bigTorusDegree                                 |
|                                                      |
|o7 = | -1 |                                           |
|     | -1 |                                           |
|     |  0 |                                           |
|     |  2 |                                           |
|     |  0 |                                           |
|                                                      |
|       5                                              |
|o7 : ZZ                                               |
+------------------------------------------------------+
|i8 : simplexRing f                                    |
|                                                      |
|o8 = R                                                |
|                                                      |
|o8 : PolynomialRing                                   |
+------------------------------------------------------+
|i9 : target f                                         |
|                                                      |
|o9 = cokernel | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |  |
|                                                      |
|                            1                         |
|o9 : R-module, quotient of R                          |
+------------------------------------------------------+
|i10 : source f                                        |
|                                                      |
|o10 = image | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |    |
|                                                      |
|                              1                       |
|o10 : R-module, submodule of R                        |
+------------------------------------------------------+
|i11 : numerator f                                     |
|                                                      |
|o11 = | 0 |                                           |
|      | 0 |                                           |
|      | 0 |                                           |
|      | 2 |                                           |
|      | 0 |                                           |
|                                                      |
|        5                                             |
|o11 : ZZ                                              |
+------------------------------------------------------+
|i12 : denominator f                                   |
|                                                      |
|o12 = | 1 |                                           |
|      | 1 |                                           |
|      | 0 |                                           |
|      | 0 |                                           |
|      | 0 |                                           |
|                                                      |
|        5                                             |
|o12 : ZZ                                              |
+------------------------------------------------------+
|i13 : bigTorusDegree f                                |
|                                                      |
|o13 = | -1 |                                          |
|      | -1 |                                          |
|      |  0 |                                          |
|      |  2 |                                          |
|      |  0 |                                          |
|                                                      |
|        5                                             |
|o13 : ZZ                                              |
+------------------------------------------------------+
|i14 : numeratorMonomial f                             |
|                                                      |
|       2                                              |
|o14 = x                                               |
|       3                                              |
|                                                      |
|o14 : R                                               |
+------------------------------------------------------+
|i15 : degree f                                        |
|                                                      |
|o15 = 0                                               |
|                                                      |
|o15 : Vector                                          |
+------------------------------------------------------+
|i16 : grading f                                       |
|                                                      |
|o16 = | -1 -1 -1 -1 |                                 |
|      | 1  0  0  0  |                                 |
|      | 0  1  0  0  |                                 |
|      | 0  0  1  0  |                                 |
|      | 0  0  0  1  |                                 |
|                                                      |
|               5       4                              |
|o16 : Matrix ZZ  <-- ZZ                               |
+------------------------------------------------------+
|i17 : isHomogeneous f                                 |
|                                                      |
|o17 = true                                            |
+------------------------------------------------------+
|i18 : relationsCoefficients f                         |
|                                                      |
|o18 = 0                                               |
|                                                      |
|               1                                      |
|o18 : Matrix ZZ  <-- 0                                |
+------------------------------------------------------+
|i19 : parameters f                                    |
|                                                      |
|o19 = | 0 |                                           |
|      | 0 |                                           |
|      | 0 |                                           |
|      | 0 |                                           |
|      | 1 |                                           |
|                                                      |
|               5       1                              |
|o19 : Matrix ZZ  <-- ZZ                               |
+------------------------------------------------------+
|i20 : dim f                                           |
|                                                      |
|o20 = 1                                               |
+------------------------------------------------------+
|i21 : isNonzero f                                     |
|                                                      |
|o21 = true                                            |
+------------------------------------------------------+
|i22 : isTrivial f                                     |
|                                                      |
|o22 = false                                           |
+------------------------------------------------------+

See also
========

  * simplexRing -- The underlying polynomial ring of a
    deformation or face or complex.
  * target(FirstOrderDeformation), --
    The target of a deformation.
  * source(FirstOrderDeformation), --
    The source of a deformation.
  * bigTorusDegree -- The big torus degree of a
    deformation.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * numeratorMonomial -- The numerator monomial of a
    deformation.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
  * grading(FirstOrderDeformation),
    -- The small torus grading of a deformation.
  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
  * relationsCoefficients -- Relations between
    the coefficients of a deformation.
  * parameters -- Parameters of a deformation.
  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
  * isNonzero -- Check whether a deformation is non-zero.
  * isTrivial -- Check whether a deformation is trivial.
  * laurent -- Converts an exponent vector or a deformation
    into a Laurent monomial.
  * toHom -- Convert a first order deformation into a
    homomorphism.
  * totalSpace -- Total space of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4298:0.

Face -- The class of all faces of complexes or co-complexes.
************************************************************

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

The class of all faces of Complex,es or CoComplex,
es.

Creating faces:

Faces can be created by face, by specifying a List (Macaulay2Doc),
or Set (Macaulay2Doc), of variables of a
PolynomialRing (Macaulay2Doc), and some more optional data.

Usually faces are accessed as faces of a complex, C using the
ScriptedFunctor (Macaulay2Doc), C.fc with the subscripts
"dimension of the face" and "index of the face".

The data stored in a face F:

F.vert, a list with the vertices of F, which are variables of a
PolynomialRing (Macaulay2Doc), R. We use a list to prevent
Macaulay from reordering sets or monomials.

F.ofComplex, a list with the Complex,es and CoComplex,
es of which F is a face (optional).

{}it F.indices}, a list with the indices of the face in its complexes. An index
is a list {dim F, index of F in C.fc_(dim F)}.

F.dualFace, the dual face of F (optional, is stored for later use when computed
by dualize). Note that also the dual face dF of F then has
dF.dualFace=F.

This data can also be accessed by the methods listed below.

Note that the lattice data of the vertices is stored in R.grading via
addCokerGrading. If no coker grading is present then many
functions, like simplex, idealToComplex,
idealToCoComplex, add the standard projective space
grading raysPPn.

Notes on the implementation:

In order to save memory identical faces are not created several times, e.g., if
subComplex,es are created from given ones any face of the
subcomplex is identical to a face of the given one.

So far the list F.ofComplex is only used for the complex which created F, but
later we will perhaps append also all other complexes F is a face of. As we
will append to the list this will be backwards compatible.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : addCokerGrading R                                                     |
|                                                                           |
|o2 = | -1 -1 -1 -1 |                                                       |
|     | 1  0  0  0  |                                                       |
|     | 0  1  0  0  |                                                       |
|     | 0  0  1  0  |                                                       |
|     | 0  0  0  1  |                                                       |
|                                                                           |
|              5       4                                                    |
|o2 : Matrix ZZ  <-- ZZ                                                     |
+---------------------------------------------------------------------------+
|i3 : C=simplex R                                                           |
|                                                                           |
|o3 = 4: x x x x x                                                          |
|         0 1 2 3 4                                                         |
|                                                                           |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0 |
+---------------------------------------------------------------------------+
|i4 : F=C.fc_1_0                                                            |
|                                                                           |
|o4 = x x                                                                   |
|      0 1                                                                  |
|                                                                           |
|o4 : face with 2 vertices                                                  |
+---------------------------------------------------------------------------+
|i5 : F.vert                                                                |
|                                                                           |
|o5 = {x , x }                                                              |
|       0   1                                                               |
|                                                                           |
|o5 : List                                                                  |
+---------------------------------------------------------------------------+
|i6 : coordinates F                                                         |
|                                                                           |
|o6 = {{-1, -1, -1, -1}, {1, 0, 0, 0}}                                      |
|                                                                           |
|o6 : List                                                                  |
+---------------------------------------------------------------------------+
|i7 : (F.ofComplex)#0==C                                                    |
|                                                                           |
|o7 = true                                                                  |
+---------------------------------------------------------------------------+
|i8 : bC=boundaryOfPolytope C                                               |
|                                                                           |
|o8 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o8 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i9 : F==bC.fc_1_0                                                          |
|                                                                           |
|o9 = true                                                                  |
+---------------------------------------------------------------------------+

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.
  * ofComplex -- The complex of a face.
  * vert -- The vertices of a face or complex.
  * dual (Macaulay2Doc) -- dual module or map
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.
  * simplex -- Simplex in the variables of a polynomial ring.
  * boundaryOfPolytope -- The boundary of a
    polytope.
  * coordinates -- The coordinates of a face.

Methods that use a face:
========================

  * "closedStar(Face,Complex)" -- see closedStar, -- The
    closed star of a face of a complex.
  * complement(Face) -- Compute the complement
    face of a simplex.
  * "coordinates(Face)" -- see coordinates, -- The
    coordinates of a face.
  * "coordinates(Face,Complex)" -- see coordinates, -- The
    coordinates of a face.
  * "deformationsFace(Face,Complex)" -- see deformationsFace,
    -- Compute the deformations associated to a face.
  * "deformationsFace(Face,Complex,Ideal)" -- see deformationsFace,
    -- Compute the deformations associated to a face.
  * dim(Face) -- Compute the dimension of a face.
  * dim(Face,Complex) -- Compute the dimension
    of a face.
  * dim(Face,PolynomialRing) -- Compute
    the dimension of a face.
  * "dualize(Face)" -- see dualize, -- The dual of a face or
    complex.
  * Face == Face -- Compare two faces.
  * "faceToMonomial(Face)" -- see faceToMonomial, -- The
    monomial of a face.
  * "faceToMonomial(Face,PolynomialRing)" -- see faceToMonomial,
    -- The monomial of a face.
  * indices(Face) -- The indices of a face.
  * "intersectFaces(Face,Face)" -- see intersectFaces, --
    The intersection of two faces.
  * "isSubface(Face,Face)" -- see isSubface, -- Checks whether
    a face is a subface of another face.
  * "link(Face,Complex)" -- see link, -- The link of a face of a
    complex.
  * net(Face) -- Printing faces.
  * "ofComplex(Face)" -- see ofComplex, -- The complex of a
    face.
  * "simplexDim(Face)" -- see simplexDim, -- The dimension of
    a face inside the vertex simplex.
  * simplexRing(Face) -- The underlying
    polynomial ring of a face.
  * "vert(Face)" -- see vert, -- The vertices of a face or complex.

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

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

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

The source of this document is in SRdeformations.m2:5239:0.

face -- Generate a face.
************************

  * Usage:
        face(L)
        face(S)
        face(L,C)
        face(L,C,d,j)
  * Inputs:
      * L, a list (Macaulay2Doc),
      * S, a set (Macaulay2Doc),
      * C, an embedded complex,
      * d, an integer (Macaulay2Doc), bigger or equal to -1
      * j, an integer (Macaulay2Doc), non-negative
  * Outputs:
      * a face,

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

Generate a Face, F from a list L (or set S) of vertices. If the
additional argument C is given it sets F.ofComplex={C} to store the complex of
which F is a face of.

If d and j are given then F.indices={{d,j}} for storing the face dimension d
and its index j in (F.ofComplex)#0.

+-------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                      |
|                                                                         |
|o1 = R                                                                   |
|                                                                         |
|o1 : PolynomialRing                                                      |
+-------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                         |
|o2 = ideal (x x , x x , x x , x x , x x )                                |
|             0 1   1 2   2 3   3 4   0 4                                 |
|                                                                         |
|o2 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i3 : C=idealToComplex I                                                  |
|                                                                         |
|o3 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o3 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i4 : F=C.fc_1_0                                                          |
|                                                                         |
|o4 = x x                                                                 |
|      0 2                                                                |
|                                                                         |
|o4 : face with 2 vertices                                                |
+-------------------------------------------------------------------------+
|i5 : F==face(vert F,C,1,0)                                               |
|                                                                         |
|o5 = true                                                                |
+-------------------------------------------------------------------------+

See also
========

  * Face -- The class of all faces of complexes or co-complexes.
  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

Ways to use face:
=================

  * "face(List)"
  * "face(List,Complex)"
  * "face(List,Complex,ZZ,ZZ)"
  * "face(Set)"

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

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

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

The source of this document is in SRdeformations.m2:7144:0.

Face == Face -- Compare two faces.
**********************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        F==G
  * Inputs:
      * F, a face,
      * G, a face,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether F and G are equal.

+-------------------------------------+
|i1 : R=QQ[x_0..x_4];                 |
+-------------------------------------+
|i2 : face {x_0,x_1} == face {x_1,x_0}|
|                                     |
|o2 = true                            |
+-------------------------------------+
|i3 : addCokerGrading R;              |
|                                     |
|              5       4              |
|o3 : Matrix ZZ  <-- ZZ               |
+-------------------------------------+
|i4 : C=simplex R;                    |
+-------------------------------------+
|i5 : bC=boundaryOfPolytope C;        |
+-------------------------------------+
|i6 : F=bC.fc_2_0                     |
|                                     |
|o6 = x x x                           |
|      0 1 2                          |
|                                     |
|o6 : face with 3 vertices            |
+-------------------------------------+
|i7 : dF=dualize F                    |
|                                     |
|o7 = v v                             |
|      0 1                            |
|                                     |
|o7 : face with 2 vertices            |
+-------------------------------------+
|i8 : F== dualize dF                  |
|                                     |
|o8 = true                            |
+-------------------------------------+

See also
========

  * Face -- The class of all faces of complexes or co-complexes.
  * face -- Generate a face.
  * Complex -- The class of all embedded complexes.
  * facets -- The maximal faces of a complex.
  * fc -- The faces of a complex.

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

  * Face == Face -- Compare two faces.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5608:0.

faceToMonomial -- The monomial of a face.
*****************************************

  * Usage:
        faceToMonomial(F)
  * Inputs:
      * F, a face,
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an embedded complex,

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

Returns the product of the vertices of a face.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                      |
+--------------------------------------------------------------------------+
|i2 : C=simplex R                                                          |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : F=C.fc_2_0                                                           |
|                                                                          |
|o3 = x x x                                                                |
|      0 1 2                                                               |
|                                                                          |
|o3 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i4 : vert F                                                               |
|                                                                          |
|o4 = {x , x , x }                                                         |
|       0   1   2                                                          |
|                                                                          |
|o4 : List                                                                 |
+--------------------------------------------------------------------------+
|i5 : faceToMonomial F                                                     |
|                                                                          |
|o5 = x x x                                                                |
|      0 1 2                                                               |
|                                                                          |
|o5 : R                                                                    |
+--------------------------------------------------------------------------+

See also
========

  * vert -- The vertices of a face or complex.

Ways to use faceToMonomial:
===========================

  * "faceToMonomial(Face)"
  * "faceToMonomial(Face,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:5670:0.

facets -- The maximal faces of a complex.
*****************************************

  * Usage:
        facets(C)
  * Inputs:
      * C, an embedded complex,
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

The maximal faces of C arranged in a list of lists with ascending dimension of
the facets.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=fullCyclicPolytope(3,R)                                               |
|                                                                             |
|o2 = 3: x x x x x x                                                          |
|         0 1 2 3 4 5                                                         |
|                                                                             |
|o2 : complex of dim 3 embedded in dim 3 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0   |
+-----------------------------------------------------------------------------+
|i3 : facets C                                                                |
|                                                                             |
|o3 = {{}, {}, {}, {}, {x x x x x x }}                                        |
|                        0 1 2 3 4 5                                          |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : dC=boundaryOfPolytope(C);                                               |
+-----------------------------------------------------------------------------+
|i5 : facets dC                                                               |
|                                                                             |
|o5 = {{}, {}, {}, {x x x , x x x , x x x , x x x , x x x , x x x , x x x ,   |
|                    0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5    |
|     ------------------------------------------------------------------------|
|     x x x }, {}}                                                            |
|      3 4 5                                                                  |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * fc -- The faces of a complex.
  * polytopalFacets -- The facets of a polytope.

Ways to use facets:
===================

  * "facets(Complex)"
  * "facets(List)"

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

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

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

The source of this document is in SRdeformations.m2:6284:0.

fc -- The faces of a complex.
*****************************

  * Usage:
        fc(C)
        fc(C,d)
  * Inputs:
      * C, an embedded complex,
      * d, an integer (Macaulay2Doc), positive
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns a list with entries lists with the faces of C starting in dimension -1.
If d is given then faces of dimension d are returned.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                           |
|                                                                             |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x               |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5              |
|                                                                             |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i3 : fc C                                                                    |
|                                                                             |
|o3 = {{{}}, {x , x , x , x , x , x }, {x x , x x , x x , x x , x x , x x ,   |
|              0   1   2   3   4   5     0 1   0 2   1 2   0 3   2 3   0 4    |
|     ------------------------------------------------------------------------|
|     x x , x x , x x , x x , x x , x x }, {x x x , x x x , x x x , x x x ,   |
|      3 4   0 5   1 5   2 5   3 5   4 5     0 1 2   0 2 3   0 3 4   0 1 5    |
|     ------------------------------------------------------------------------|
|     x x x , x x x , x x x , x x x }, {}, {}, {}}                            |
|      1 2 5   2 3 5   0 4 5   3 4 5                                          |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : fc(C,1)                                                                 |
|                                                                             |
|o4 = {x x , x x , x x , x x , x x , x x , x x , x x , x x , x x , x x , x x }|
|       0 1   0 2   1 2   0 3   2 3   0 4   3 4   0 5   1 5   2 5   3 5   4 5 |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use fc:
===============

  * "fc(Complex)"
  * "fc(Complex,ZZ)"

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

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

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

The source of this document is in SRdeformations.m2:6157:0.

file -- Store result of a computation in a file.
************************************************

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

If the option file=>fn with a String (Macaulay2Doc), fn is given
then the result of the computation is stored in the file fn.

Caveat
======

This works only when using the package ConvexInterface.

See also
========

  * PT1 -- Compute the deformation polytope associated to a
    Stanley-Reisner complex.
  * convHull -- The convex hull complex.
  * hull -- The positive hull complex.

Functions with optional argument named file:
============================================

  * "convHull(...,file=>...)"
  * "hull(...,file=>...)"
  * "PT1(...,file=>...)"

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

The object file, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:7801:0.

FirstOrderDeformation -- The class of all first order deformations of monomial ideals.
**************************************************************************************

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

The class of all first order deformations of reduced monomial ideals. Elements
represent a big torus (i.e., torus on the variables of a PolynomialRing (Macaulay2Doc))
graded part of the vector space of first order
deformations.  By results of Klaus Altmann and Jan Arthur Christophersen the
dimension is either 0 or 1 (for manifolds, though this is not required by the
implementation).

First order deformations can be created by firstOrderDeformation,
by specifying a matrix with generators of a reduced
monomial ideal and the exponent vector of a Laurent-monomial (i.e., a  big
torus degree).

Functions producing (sets of) first order deformations:

deform, -- Compute the deformations associated to a
Stanley-Reisner complex.

See deformationsFace, -- Compute the deformations
associated to a face

See trivialDeformations, -- Compute the trivial
deformations

See firstOrderDeformation, -- Makes a first order
deformation

The data stored in a first order deformation f are

f.gens, a matrix (Macaulay2Doc), with generators of source (Macaulay2Doc),
of the homomorphisms represented by f.

f.bigTorusDegree, the exponent vector of the Laurent monomial.

f.degree, the small torus (i.e., with respect to the grading added to R by
addCokerGrading) degree of f.

f.isHomogeneous, a Boolean (Macaulay2Doc), indicating if f.degree
is zero.

f.relevantGens, a Matrix (Macaulay2Doc), with those elements of
f.gens which are relevant to the deformation f (i.e., those m which have
numerator(m*laurent(f)) not in ideal(f.gens)).

f.relationsCoefficients, see matrix (Macaulay2Doc), of relations on
coefficients of f. The rows correspond to the generators given in
f.relevantGens.

f.parameters, a Matrix (Macaulay2Doc), whose image is the
kernel (Macaulay2Doc), of the transpose (Macaulay2Doc),
of f.relationsCoefficients extended by zeros for the elements of f.gens not in
f.relevantGens. The rows correspond to the generators given in f.gens.

f.dim, the dimension of the f-graded part of the deformation space of
ideal (Macaulay2Doc), f.gens.

f.isNonzero, a Boolean (Macaulay2Doc), indicating whether f is
non-zero.

f.isTrivial, a Boolean (Macaulay2Doc), indicating whether f is
trivial, i.e., see denominatorMonomial, f has degree 1.

For an example see Example first order deformation.

This data can also be accessed by the methods listed below.

See laurent, represents f as a Laurent monomial, see toHom,
represents f as a homomorphism.

See totalSpace, computes the total space of f.

+-------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                   |
+-------------------------------------------------------+
|i2 : addCokerGrading(R)                                |
|                                                       |
|o2 = | -1 -1 -1 -1 |                                   |
|     | 1  0  0  0  |                                   |
|     | 0  1  0  0  |                                   |
|     | 0  0  1  0  |                                   |
|     | 0  0  0  1  |                                   |
|                                                       |
|              5       4                                |
|o2 : Matrix ZZ  <-- ZZ                                 |
+-------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)  |
|                                                       |
|o3 = ideal (x x , x x , x x , x x , x x )              |
|             0 1   1 2   2 3   3 4   0 4               |
|                                                       |
|o3 : Ideal of R                                        |
+-------------------------------------------------------+
|i4 : mg=mingens I;                                     |
|                                                       |
|             1      5                                  |
|o4 : Matrix R  <-- R                                   |
+-------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0}) |
|                                                       |
|       2                                               |
|      x                                                |
|       3                                               |
|o5 = ----                                              |
|     x x                                               |
|      0 1                                              |
|                                                       |
|o5 : first order deformation space of dimension 1      |
+-------------------------------------------------------+
|i6 : degree f                                          |
|                                                       |
|o6 = 0                                                 |
|                                                       |
|o6 : Vector                                            |
+-------------------------------------------------------+
|i7 : dim f                                             |
|                                                       |
|o7 = 1                                                 |
+-------------------------------------------------------+
|i8 : f1=firstOrderDeformation(mg,vector {-1,1,0,0,0})  |
|                                                       |
|     x                                                 |
|      1                                                |
|o8 = --                                                |
|     x                                                 |
|      0                                                |
|                                                       |
|o8 : first order deformation space of dimension 1      |
+-------------------------------------------------------+
|i9 : isTrivial f1                                      |
|                                                       |
|o9 = true                                              |
+-------------------------------------------------------+
|i10 : f2=firstOrderDeformation(mg,vector {0,-1,-1,2,0})|
|                                                       |
|        2                                              |
|       x                                               |
|        3                                              |
|o10 = ----                                             |
|      x x                                              |
|       1 2                                             |
|                                                       |
|o10 : first order deformation space of dimension 0     |
+-------------------------------------------------------+
|i11 : isNonzero f2                                     |
|                                                       |
|o11 = false                                            |
+-------------------------------------------------------+

Caveat
======

If we run into performance issues some of the redundant data will be removed,
so for future compatibility access the data by the corresponding method (Macaulay2Doc),
not via the MutableHashTable (Macaulay2Doc).

See also
========

  * simplexRing -- The underlying polynomial ring of a
    deformation or face or complex.
  * target(FirstOrderDeformation), --
    The target of a deformation.
  * source(FirstOrderDeformation), --
    The source of a deformation.
  * gensSource -- Generators of the source of a deformation.
  * bigTorusDegree -- The big torus degree of a
    deformation.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * numeratorMonomial -- The numerator monomial of a
    deformation.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
  * grading(FirstOrderDeformation),
    -- The small torus grading of a deformation.
  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
  * relationsCoefficients -- Relations between
    the coefficients of a deformation.
  * parameters -- Parameters of a deformation.
  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
  * isNonzero -- Check whether a deformation is non-zero.
  * isTrivial -- Check whether a deformation is trivial.
  * laurent -- Converts an exponent vector or a deformation
    into a Laurent monomial.
  * toHom -- Convert a first order deformation into a
    homomorphism.
  * totalSpace -- Total space of a deformation.
  * trivialDeformations -- Compute the trivial
    deformations.

Methods that use a first order deformation:
===========================================

  * "bigTorusDegree(FirstOrderDeformation)" -- see bigTorusDegree,
    -- The big torus degree of a deformation.
  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * "denominatorMonomial(FirstOrderDeformation)" -- see
    denominatorMonomial, -- The denominator monomial of a
    deformation.
  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
  * FirstOrderDeformation == FirstOrderDeformation
    -- Compare two first order deformations.
  * "gensSource(FirstOrderDeformation)" -- see gensSource, --
    Generators of the source of a deformation.
  * grading(FirstOrderDeformation),
    -- The small torus grading of a deformation.
  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
  * "isNonzero(FirstOrderDeformation)" -- see isNonzero, --
    Check whether a deformation is non-zero.
  * "isTrivial(FirstOrderDeformation)" -- see isTrivial, --
    Check whether a deformation is trivial.
  * "laurent(FirstOrderDeformation)" -- see laurent, -- Converts
    an exponent vector or a deformation into a Laurent monomial.
  * net(FirstOrderDeformation) -- Pretty
    print for deformations.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * "numeratorMonomial(FirstOrderDeformation)" -- see numeratorMonomial,
    -- The numerator monomial of a deformation.
  * "parameters(FirstOrderDeformation)" -- see parameters, --
    Parameters of a deformation.
  * "relationsCoefficients(FirstOrderDeformation)" -- see
    relationsCoefficients, -- Relations between the
    coefficients of a deformation.
  * simplexRing(FirstOrderDeformation)
    -- The underlying polynomial ring
    of a deformation or face.
  * source(FirstOrderDeformation), --
    The source of a deformation.
  * target(FirstOrderDeformation), --
    The target of a deformation.
  * "toHom(FirstOrderDeformation)" -- see toHom, -- Convert a
    first order deformation into a homomorphism.
  * "totalSpace(FirstOrderDeformation,PolynomialRing)" -- see totalSpace,
    -- Total space of a deformation.

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

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

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

The source of this document is in SRdeformations.m2:4242:0.

firstOrderDeformation -- Makes a first order deformation.
*********************************************************

  * Usage:
        firstOrderDeformation(mg,v)
        firstOrderDeformation(I,v)
  * Inputs:
      * I, an ideal (Macaulay2Doc), monomial, reduced, in a
        PolynomialRing (Macaulay2Doc), or
      * I, a monomial ideal (Macaulay2Doc), reduced
      * mg, a matrix (Macaulay2Doc), row, with generators of a
        reduced monomial ideal.
  * Outputs:
      * a first order deformation,

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

Generates a first order deformation ideal (Macaulay2Doc), mg. If it
is given an ideal I then generators (Macaulay2Doc), of I are
stored to have a reference for parameters. You can also give
non-minimal generators.

+-----------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                 |
+-----------------------------------------------------+
|i2 : addCokerGrading(R)                              |
|                                                     |
|o2 = | -1 -1 -1 -1 |                                 |
|     | 1  0  0  0  |                                 |
|     | 0  1  0  0  |                                 |
|     | 0  0  1  0  |                                 |
|     | 0  0  0  1  |                                 |
|                                                     |
|              5       4                              |
|o2 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)|
|                                                     |
|o3 = ideal (x x , x x , x x , x x , x x )            |
|             0 1   1 2   2 3   3 4   0 4             |
|                                                     |
|o3 : Ideal of R                                      |
+-----------------------------------------------------+
|i4 : mg=mingens I;                                   |
|                                                     |
|             1      5                                |
|o4 : Matrix R  <-- R                                 |
+-----------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,1,0,0,0})|
|                                                     |
|     x                                               |
|      1                                              |
|o5 = --                                              |
|     x                                               |
|      0                                              |
|                                                     |
|o5 : first order deformation space of dimension 1    |
+-----------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use firstOrderDeformation:
==================================

  * "firstOrderDeformation(Ideal,Vector)"
  * "firstOrderDeformation(Matrix,Vector)"
  * "firstOrderDeformation(MonomialIdeal,Vector)"

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

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

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

The source of this document is in SRdeformations.m2:5029:0.

FirstOrderDeformation == FirstOrderDeformation -- Compare two first order deformations.
***************************************************************************************

  * Operator: == (Macaulay2Doc),
  * Usage:
        f1==f2
  * Inputs:
      * f1, a first order deformation,
      * f2, a first order deformation,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether f1 and f2 are equal.

+-------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                   |
+-------------------------------------------------------+
|i2 : addCokerGrading(R)                                |
|                                                       |
|o2 = | -1 -1 -1 -1 |                                   |
|     | 1  0  0  0  |                                   |
|     | 0  1  0  0  |                                   |
|     | 0  0  1  0  |                                   |
|     | 0  0  0  1  |                                   |
|                                                       |
|              5       4                                |
|o2 : Matrix ZZ  <-- ZZ                                 |
+-------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)  |
|                                                       |
|o3 = ideal (x x , x x , x x , x x , x x )              |
|             0 1   1 2   2 3   3 4   0 4               |
|                                                       |
|o3 : Ideal of R                                        |
+-------------------------------------------------------+
|i4 : mg=mingens I;                                     |
|                                                       |
|             1      5                                  |
|o4 : Matrix R  <-- R                                   |
+-------------------------------------------------------+
|i5 : f1=firstOrderDeformation(mg, vector {-1,1,0,0,0}) |
|                                                       |
|     x                                                 |
|      1                                                |
|o5 = --                                                |
|     x                                                 |
|      0                                                |
|                                                       |
|o5 : first order deformation space of dimension 1      |
+-------------------------------------------------------+
|i6 : f2=firstOrderDeformation(mg, vector {0,2,0,-1,-1})|
|                                                       |
|       2                                               |
|      x                                                |
|       1                                               |
|o6 = ----                                              |
|     x x                                               |
|      3 4                                              |
|                                                       |
|o6 : first order deformation space of dimension 1      |
+-------------------------------------------------------+
|i7 : f2==f2                                            |
|                                                       |
|o7 = true                                              |
+-------------------------------------------------------+
|i8 : f2==f1                                            |
|                                                       |
|o8 = false                                             |
+-------------------------------------------------------+

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

  * FirstOrderDeformation == FirstOrderDeformation
    -- Compare two first order deformations.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5056:0.

fullCyclicPolytope -- Cyclic polytope.
**************************************

  * Usage:
        fullCyclicPolytope(d,R)
  * Inputs:
      * d, an integer (Macaulay2Doc), positive
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * C, an embedded complex,

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

Returns the full cyclic polytope of dimension d with vertices the variables of
R. A coker grading is added to R via the vertices of the moment curve (if R
already has a coker grading then a warning is displayed) and translated such
that 0 lies in the interior of C.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : C=fullCyclicPolytope(3,R)                                            |
|                                                                          |
|o2 = 3: x x x x x x                                                       |
|         0 1 2 3 4 5                                                      |
|                                                                          |
|o2 : complex of dim 3 embedded in dim 3 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0|
+--------------------------------------------------------------------------+

See also
========

  * boundaryCyclicPolytope -- The boundary
    complex of a cyclic polytope.

Ways to use fullCyclicPolytope:
===============================

  * "fullCyclicPolytope(ZZ,PolynomialRing)"
  * "fullCyclicPolytope(ZZ,PolynomialRing,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:6187:0.

fvector -- The F-vector of a complex.
*************************************

  * Usage:
        fvector(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a list (Macaulay2Doc),

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

The fvector of C. This is printed always when printing a complex and the faces
are known.

+-------------------------------+
|i1 : R=QQ[x_0..x_5];           |
+-------------------------------+
|i2 : C=fullCyclicPolytope(3,R);|
+-------------------------------+
|i3 : fvector C                 |
|                               |
|o3 = {1, 6, 12, 8, 1}          |
|                               |
|o3 : List                      |
+-------------------------------+
|i4 : eulerCharacteristic C     |
|                               |
|o4 = 0                         |
+-------------------------------+
|i5 : dC=boundaryOfPolytope(C); |
+-------------------------------+
|i6 : fvector dC                |
|                               |
|o6 = {1, 6, 12, 8, 0}          |
|                               |
|o6 : List                      |
+-------------------------------+
|i7 : eulerCharacteristic dC    |
|                               |
|o7 = 1                         |
+-------------------------------+

See also
========

  * eulerCharacteristic -- The Euler characteristic
    of a complex.
  * fc -- The faces of a complex.

Ways to use fvector:
====================

  * "fvector(Complex)"
  * "fvector(List)"

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

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

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

The source of this document is in SRdeformations.m2:6369:0.

gensSource -- Generators of the source of a deformation.
********************************************************

  * Usage:
        gensSource(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns generators of the source(FirstOrderDeformation),
f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : gensSource f                                     |
|                                                      |
|o6 = | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |           |
|                                                      |
|             1      5                                 |
|o6 : Matrix R  <-- R                                  |
+------------------------------------------------------+

See also
========

  * source(FirstOrderDeformation), --
    The source of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use gensSource:
=======================

  * "gensSource(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4845:0.

globalSections -- The global sections of a toric divisor.
*********************************************************

  * Usage:
        globalSections(A,v)
        globalSections(A,v,L)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * v, a vector (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

Computes the global sections of a toric Weil divisor D with coefficients v with
respect to the coker grading by A. In the same way as v they are represented by
vectors (exponent vectors of Laurent monomials in rank target A variables).

If a list of indices L in {0..rank target A -1} is specified, then those
Laurent monomial exponents are computed, which induce a linear equivalence of D
to an effective divisor with support precisely on L.

+------------------------------------------------+
|i1 : A=matrix {{1, 0}, {0, 1}, {-1, -1}}        |
|                                                |
|o1 = | 1  0  |                                  |
|     | 0  1  |                                  |
|     | -1 -1 |                                  |
|                                                |
|              3       2                         |
|o1 : Matrix ZZ  <-- ZZ                          |
+------------------------------------------------+
|i2 : b=vector {2,0,0}                           |
|                                                |
|o2 = | 2 |                                      |
|     | 0 |                                      |
|     | 0 |                                      |
|                                                |
|       3                                        |
|o2 : ZZ                                         |
+------------------------------------------------+
|i3 : globalSections(A,b)                        |
|                                                |
|o3 = {| -2 |, | -2 |, | -2 |, | -1 |, | -1 |, 0}|
|      |  0 |  |  1 |  |  2 |  |  0 |  |  1 |    |
|      |  2 |  |  1 |  |  0 |  |  1 |  |  0 |    |
|                                                |
|o3 : List                                       |
+------------------------------------------------+
|i4 : A=matrix {{1, 0}, {0, 1}, {-1, -1},{1,1}}  |
|                                                |
|o4 = | 1  0  |                                  |
|     | 0  1  |                                  |
|     | -1 -1 |                                  |
|     | 1  1  |                                  |
|                                                |
|              4       2                         |
|o4 : Matrix ZZ  <-- ZZ                          |
+------------------------------------------------+
|i5 : b=vector {2,0,0,0}                         |
|                                                |
|o5 = | 2 |                                      |
|     | 0 |                                      |
|     | 0 |                                      |
|     | 0 |                                      |
|                                                |
|       4                                        |
|o5 : ZZ                                         |
+------------------------------------------------+
|i6 : globalSections(A,b)                        |
|                                                |
|o6 = {| -2 |, | -1 |, 0}                        |
|      |  2 |  |  1 |                            |
|      |  0 |  |  0 |                            |
|      |  0 |  |  0 |                            |
|                                                |
|o6 : List                                       |
+------------------------------------------------+
|i7 : globalSections(A,b,{1})                    |
|                                                |
|o7 = {| -2 |}                                   |
|      |  2 |                                    |
|      |  0 |                                    |
|      |  0 |                                    |
|                                                |
|o7 : List                                       |
+------------------------------------------------+

Caveat
======

This uses the package Polyhedra (if ConvexInterface.m2 is not present) to
compute the lattice points of a convex hull.

Ways to use globalSections:
===========================

  * "globalSections(Matrix,Vector)"
  * "globalSections(Matrix,Vector,List)"

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

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

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

The source of this document is in SRdeformations.m2:6407:0.

grading -- The grading of a first order deformation or complex or polynomial ring.
**********************************************************************************

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

The coker grading of a FirstOrderDeformation, or
Complex, or PolynomialRing (Macaulay2Doc).

Ways to use grading:
====================

  * grading(Complex) -- The grading of a complex.
  * grading(FirstOrderDeformation),
    -- The small torus grading of a deformation.
  * grading(PolynomialRing) -- The coker
    grading of a polynomial ring.

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

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

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

The source of this document is in SRdeformations.m2:4599:0.

grading(Complex) -- The grading of a complex.
*********************************************

  * Function: grading,
  * Usage:
        grading(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns C.simplexRing.grading. The output has the coordinates of the vertices
of C in its rows.

+-----------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                  |
|                                                     |
|o1 = R                                               |
|                                                     |
|o1 : PolynomialRing                                  |
+-----------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)|
|                                                     |
|o2 = ideal (x x , x x , x x , x x , x x )            |
|             0 1   1 2   2 3   3 4   0 4             |
|                                                     |
|o2 : Ideal of R                                      |
+-----------------------------------------------------+
|i3 : C=idealToComplex I;                             |
+-----------------------------------------------------+
|i4 : grading C                                       |
|                                                     |
|o4 = | -1 -1 -1 -1 |                                 |
|     | 1  0  0  0  |                                 |
|     | 0  1  0  0  |                                 |
|     | 0  0  1  0  |                                 |
|     | 0  0  0  1  |                                 |
|                                                     |
|              5       4                              |
|o4 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+

See also
========

  * idealToComplex -- The complex associated to a
    reduced monomial ideal.

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

  * grading(Complex) -- The grading of a complex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:7332:0.

grading(FirstOrderDeformation) -- The small torus grading of a deformation.
***************************************************************************

  * Function: grading,
  * Usage:
        grading(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns the small torus grading of R = See simplexRing, C, i.e.,
the grading added to R by addCokerGrading.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : grading f                                        |
|                                                      |
|o6 = | -1 -1 -1 -1 |                                  |
|     | 1  0  0  0  |                                  |
|     | 0  1  0  0  |                                  |
|     | 0  0  1  0  |                                  |
|     | 0  0  0  1  |                                  |
|                                                      |
|              5       4                               |
|o6 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+

See also
========

  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.
  * firstOrderDeformation -- Makes a first order
    deformation.

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

  * grading(FirstOrderDeformation),
    -- The small torus grading of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4657:0.

grading(PolynomialRing) -- The coker grading of a polynomial ring.
******************************************************************

  * Function: grading,
  * Usage:
        grading(R)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns the small torus grading (coker grading) of R , i.e., the grading added
to R by addCokerGrading.

+------------------------+
|i1 : R=QQ[x_0..x_4];    |
+------------------------+
|i2 : addCokerGrading(R);|
|                        |
|              5       4 |
|o2 : Matrix ZZ  <-- ZZ  |
+------------------------+
|i3 : grading R          |
|                        |
|o3 = | -1 -1 -1 -1 |    |
|     | 1  0  0  0  |    |
|     | 0  1  0  0  |    |
|     | 0  0  1  0  |    |
|     | 0  0  0  1  |    |
|                        |
|              5       4 |
|o3 : Matrix ZZ  <-- ZZ  |
+------------------------+

See also
========

  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * grading(PolynomialRing) -- The coker
    grading of a polynomial ring.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4628:0.

HH Complex -- Compute the homology of a complex.
************************************************

  * Function: homology (Macaulay2Doc),
  * Usage:
        homology(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a list (Macaulay2Doc), of finitely generated abelian groups
        (type defined in ConvexInterface)

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

Computes the homology of a complex (not necessarily simplicial).

Caveat
======

To use this the package ConvexInterface has to be installed.

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

  * HH Complex -- Compute the homology of a complex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:7605:0.

hull -- The positive hull complex.
**********************************

  * Usage:
        hull(L)
        hull(fn)
  * Inputs:
      * L, a list (Macaulay2Doc), of Vector (Macaulay2Doc),
        s lying all in the same space.
      * fn, a string (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * file, => ..., default value null, Store result of a
        computation in a file.
  * Outputs:
      * C, an embedded complex,

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

Returns the cone which is the hull of lattice vectors in L. The output has
C.isPolytope==true.

If applied to the string fn the result of a previous computation stored via the
option file, is read from the file fn.

The hull of L has to be strictly convex.

+-----------------------------------------------------------------------------+
|i1 : L= {{0,1,1,0,0},{0,1,0,1,0},{0,1,0,0,0},{1,0,0,0,1},{1,0,-1,-1,-1},{1,0,|
|-----------------------------------------------------------------------------|
|0,0,0}};                                                                     |
+-----------------------------------------------------------------------------+
|i2 : L=apply(L,vector)                                                       |
|                                                                             |
|o2 = {| 0 |, | 0 |, | 0 |, | 1 |, |  1 |, | 1 |}                             |
|      | 1 |  | 1 |  | 1 |  | 0 |  |  0 |  | 0 |                              |
|      | 1 |  | 0 |  | 0 |  | 0 |  | -1 |  | 0 |                              |
|      | 0 |  | 1 |  | 0 |  | 0 |  | -1 |  | 0 |                              |
|      | 0 |  | 0 |  | 0 |  | 1 |  | -1 |  | 0 |                              |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : C=hull L                                                                |
|                                                                             |
|o3 = 4: y y y y y y                                                          |
|         0 1 2 3 4 5                                                         |
|                                                                             |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 6, 14, 16, 8, 1}, Euler = |
|-----------------------------------------------------------------------------|
|0                                                                            |
+-----------------------------------------------------------------------------+
|i4 : C.grading                                                               |
|                                                                             |
|o4 = | 1 0 0  0  0  |                                                        |
|     | 0 1 0  0  0  |                                                        |
|     | 0 1 1  0  0  |                                                        |
|     | 0 1 0  1  0  |                                                        |
|     | 1 0 -1 -1 -1 |                                                        |
|     | 1 0 0  0  1  |                                                        |
|                                                                             |
|              6       5                                                      |
|o4 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i5 : dC=dualize C                                                            |
|                                                                             |
|o5 = 4: v v v v v v v v                                                      |
|         0 1 2 3 4 5 6 7                                                     |
|                                                                             |
|o5 : complex of dim 4 embedded in dim 4 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 8, 16, 14, 6, 1}, Euler = |
|-----------------------------------------------------------------------------|
|0                                                                            |
+-----------------------------------------------------------------------------+
|i6 : dC.grading                                                              |
|                                                                             |
|o6 = | 0 1 -1 1  0  |                                                        |
|     | 0 1 1  -1 0  |                                                        |
|     | 0 1 -1 -1 0  |                                                        |
|     | 0 1 -1 -1 2  |                                                        |
|     | 1 0 0  0  1  |                                                        |
|     | 1 0 0  0  -1 |                                                        |
|     | 1 0 2  0  -1 |                                                        |
|     | 1 0 0  2  -1 |                                                        |
|                                                                             |
|              8       5                                                      |
|o6 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+

Caveat
======

The cone is represented as a complex on its rays, hence if dim(Face),
is applied to a Face, it will return the dimension
of the corresponding cone minus one.

This uses the package Polyhedra to compute the facets. Too slow compared to
Maple/convex.

If the package ConvexInterface is loaded, then this command calls Maple/Convex.
See the corresponding option explained at SRdeformations.

See also
========

  * Complex -- The class of all embedded complexes.

Ways to use hull:
=================

  * "hull(List)"
  * "hull(String)"

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

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

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

The source of this document is in SRdeformations.m2:7897:0.

idealToCoComplex -- The co-complex associated to a reduced monomial ideal.
**************************************************************************

  * Usage:
        idealToCoComplex(I)
        idealToCoComplex(I,C)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
      * I, a monomial ideal (Macaulay2Doc),
      * C, an embedded complex,
  * Outputs:
      * an embedded co-complex,

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

The co-complex of ideals of the strata of the locus of a reduced monomial
ideal.

This is a co-complex of faces of either C, or if C is not given, a complex of
faces of simplex, ring (Macaulay2Doc), I.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                   |
|                                                                          |
|o2 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o2 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i3 : C0=simplex(R)                                                        |
|                                                                          |
|o3 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i4 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                     |
|                                                                          |
|o4 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   3 4   0 4                                  |
|                                                                          |
|o4 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i5 : C=idealToComplex(I)                                                  |
|                                                                          |
|o5 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o5 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i6 : embeddingComplex C                                                   |
|                                                                          |
|o6 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o6 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i7 : idealToComplex(I,C0)                                                 |
|                                                                          |
|o7 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i8 : complexToIdeal(C)                                                    |
|                                                                          |
|o8 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   0 4   3 4                                  |
|                                                                          |
|o8 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i9 : cC=idealToCoComplex(I,C0)                                            |
|                                                                          |
|o9 = 2: x x x  x x x  x x x  x x x  x x x                                 |
|         0 1 3  0 2 3  0 2 4  1 2 4  1 3 4                                |
|                                                                          |
|o9 : co-complex of dim 2 embedded in dim 4 (printing facets)              |
|     equidimensional, simplicial, F-vector {0, 0, 0, 5, 5, 1}, Euler = 1  |
+--------------------------------------------------------------------------+
|i10 : cC==complement C                                                    |
|                                                                          |
|o10 = true                                                                |
+--------------------------------------------------------------------------+
|i11 : I==coComplexToIdeal(cC)                                             |
|                                                                          |
|o11 = true                                                                |
+--------------------------------------------------------------------------+
|i12 : dualize cC                                                          |
|                                                                          |
|o12 = 1: v v  v v  v v  v v  v v                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o12 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+

See also
========

  * coComplexToIdeal -- The monomial ideal associated
    to a CoComplex.
  * idealToComplex -- The complex associated to a
    reduced monomial ideal.
  * complexToIdeal -- The monomial ideal associated to a
    complex.
  * embeddingComplex -- The embedding complex of a
    complex or co-complex.

Ways to use idealToCoComplex:
=============================

  * "idealToCoComplex(Ideal)"
  * "idealToCoComplex(Ideal,Complex)"
  * "idealToCoComplex(MonomialIdeal)"
  * "idealToCoComplex(MonomialIdeal,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6594:0.

idealToComplex -- The complex associated to a reduced monomial ideal.
*********************************************************************

  * Usage:
        idealToComplex(I)
        idealToComplex(I,C)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
      * I, a monomial ideal (Macaulay2Doc),
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

The Stanley-Complex associated to a reduced monomial ideal.

This is a complex of faces of either C, or if C is not given, a complex of
faces of simplex, ring (Macaulay2Doc), I.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                   |
|                                                                          |
|o2 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o2 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i3 : C0=simplex(R)                                                        |
|                                                                          |
|o3 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o3 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i4 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                     |
|                                                                          |
|o4 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   3 4   0 4                                  |
|                                                                          |
|o4 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i5 : C=idealToComplex(I)                                                  |
|                                                                          |
|o5 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o5 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i6 : embeddingComplex C                                                   |
|                                                                          |
|o6 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o6 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i7 : idealToComplex(I,C0)                                                 |
|                                                                          |
|o7 = 1: x x  x x  x x  x x  x x                                           |
|         0 2  0 3  1 3  1 4  2 4                                          |
|                                                                          |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1 |
+--------------------------------------------------------------------------+
|i8 : complexToIdeal(C)                                                    |
|                                                                          |
|o8 = ideal (x x , x x , x x , x x , x x )                                 |
|             0 1   1 2   2 3   0 4   3 4                                  |
|                                                                          |
|o8 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i9 : cC=idealToCoComplex(I,C0)                                            |
|                                                                          |
|o9 = 2: x x x  x x x  x x x  x x x  x x x                                 |
|         0 1 3  0 2 3  0 2 4  1 2 4  1 3 4                                |
|                                                                          |
|o9 : co-complex of dim 2 embedded in dim 4 (printing facets)              |
|     equidimensional, simplicial, F-vector {0, 0, 0, 5, 5, 1}, Euler = 1  |
+--------------------------------------------------------------------------+
|i10 : cC==complement C                                                    |
|                                                                          |
|o10 = true                                                                |
+--------------------------------------------------------------------------+
|i11 : I==coComplexToIdeal(cC)                                             |
|                                                                          |
|o11 = true                                                                |
+--------------------------------------------------------------------------+
|i12 : dualize cC                                                          |
|                                                                          |
|o12 = 1: v v  v v  v v  v v  v v                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o12 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+

See also
========

  * coComplexToIdeal -- The monomial ideal associated
    to a CoComplex.
  * complexToIdeal -- The monomial ideal associated to a
    complex.
  * idealToCoComplex -- The co-complex associated to a
    reduced monomial ideal.
  * embeddingComplex -- The embedding complex of a
    complex or co-complex.

Ways to use idealToComplex:
===========================

  * "idealToComplex(Ideal)"
  * "idealToComplex(Ideal,Complex)"
  * "idealToComplex(MonomialIdeal)"
  * "idealToComplex(MonomialIdeal,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6549:0.

indices(Face) -- The indices of a face.
***************************************

  * Function: indices (Macaulay2Doc),
  * Usage:
        indices(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * a list (Macaulay2Doc),

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

Returns the indices of the face with respect to the first complex in
F.ofComplex. The first entry d is the dimension and the second the index of F
in the list (ofComplex F).fc_d.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                      |
+--------------------------------------------------------------------------+
|i2 : C=simplex R                                                          |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : F=C.fc_2_0                                                           |
|                                                                          |
|o3 = x x x                                                                |
|      0 1 2                                                               |
|                                                                          |
|o3 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i4 : indices F                                                            |
|                                                                          |
|o4 = {2, 0}                                                               |
|                                                                          |
|o4 : List                                                                 |
+--------------------------------------------------------------------------+

See also
========

  * ofComplex -- The complex of a face.

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

  * indices(Face) -- The indices of a face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5548:0.

intersectFaces -- The intersection of two faces.
************************************************

  * Usage:
        intersectFaces(F,G)
  * Inputs:
      * F, a face,
      * G, a face,
  * Outputs:
      * a face,

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

Returns the intersection of two faces or a list of faces.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                      |
+--------------------------------------------------------------------------+
|i2 : C=simplex R                                                          |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : F=C.fc_2_0                                                           |
|                                                                          |
|o3 = x x x                                                                |
|      0 1 2                                                               |
|                                                                          |
|o3 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i4 : G=C.fc_2_1                                                           |
|                                                                          |
|o4 = x x x                                                                |
|      0 1 3                                                               |
|                                                                          |
|o4 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i5 : intersectFaces(F,G)                                                  |
|                                                                          |
|o5 = x x                                                                  |
|      0 1                                                                 |
|                                                                          |
|o5 : face with 2 vertices                                                 |
+--------------------------------------------------------------------------+
|i6 : H=C.fc_2_2                                                           |
|                                                                          |
|o6 = x x x                                                                |
|      0 2 3                                                               |
|                                                                          |
|o6 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i7 : intersectFaces({F,G,H})                                              |
|                                                                          |
|o7 = x                                                                    |
|      0                                                                   |
|                                                                          |
|o7 : face with 1 vertex                                                   |
+--------------------------------------------------------------------------+

See also
========

  * vert -- The vertices of a face or complex.

Ways to use intersectFaces:
===========================

  * "intersectFaces(Face,Face)"
  * "intersectFaces(List)"

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

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

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

The source of this document is in SRdeformations.m2:5703:0.

isEquidimensional -- Check whether a complex or co-complex is equidimensional.
******************************************************************************

  * Usage:
        isEquidimensional(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Check whether a complex or co-complex is equidimensional.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5];                                                        |
+----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                          |
|                                                                            |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x              |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5             |
|                                                                            |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1|
+----------------------------------------------------------------------------+
|i3 : isEquidimensional(C)                                                   |
|                                                                            |
|o3 = true                                                                   |
+----------------------------------------------------------------------------+
|i4 : R=QQ[x_0..x_2];                                                        |
+----------------------------------------------------------------------------+
|i5 : I=intersect(ideal(x_0),ideal(x_1,x_2))                                 |
|                                                                            |
|o5 = ideal (x x , x x )                                                     |
|             0 2   0 1                                                      |
|                                                                            |
|o5 : Ideal of R                                                             |
+----------------------------------------------------------------------------+
|i6 : C=idealToComplex I                                                     |
|                                                                            |
|o6 = 0: x                                                                   |
|         0                                                                  |
|     1: x x                                                                 |
|         1 2                                                                |
|                                                                            |
|o6 : complex of dim 1 embedded in dim 2 (printing facets)                   |
|     non-equidimensional, simplicial, F-vector {1, 3, 1, 0}, Euler = 1      |
+----------------------------------------------------------------------------+
|i7 : isEquidimensional(C)                                                   |
|                                                                            |
|o7 = false                                                                  |
+----------------------------------------------------------------------------+

See also
========

  * boundaryCyclicPolytope -- The boundary
    complex of a cyclic polytope.
  * idealToComplex -- The complex associated to a
    reduced monomial ideal.

Ways to use isEquidimensional:
==============================

  * "isEquidimensional(Complex)"
  * "isEquidimensional(List)"

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

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

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

The source of this document is in SRdeformations.m2:7097:0.

isHomogeneous(FirstOrderDeformation) -- Check whether a deformation is homogeneous.
***********************************************************************************

  * Function: isHomogeneous (Macaulay2Doc),
  * Usage:
        isHomogeneous(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether a deformation f is homogeneous with respect to the small torus
grading, i.e., the grading added to R = See simplexRing, f by
addCokerGrading.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : isHomogeneous f                                  |
|                                                      |
|o6 = true                                             |
+------------------------------------------------------+

See also
========

  * degree(FirstOrderDeformation), --
    The small torus degree of a deformation.
  * grading -- The grading of a first order deformation or
    complex or polynomial ring.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * isHomogeneous(FirstOrderDeformation)
    -- Check whether a deformation is
    homogeneous.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4686:0.

isNonzero -- Check whether a deformation is non-zero.
*****************************************************

  * Usage:
        isNonzero(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Check whether f is non-zero.

+-------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                   |
+-------------------------------------------------------+
|i2 : addCokerGrading(R);                               |
|                                                       |
|              5       4                                |
|o2 : Matrix ZZ  <-- ZZ                                 |
+-------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)  |
|                                                       |
|o3 = ideal (x x , x x , x x , x x , x x )              |
|             0 1   1 2   2 3   3 4   0 4               |
|                                                       |
|o3 : Ideal of R                                        |
+-------------------------------------------------------+
|i4 : mg=mingens I;                                     |
|                                                       |
|             1      5                                  |
|o4 : Matrix R  <-- R                                   |
+-------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0}) |
|                                                       |
|       2                                               |
|      x                                                |
|       3                                               |
|o5 = ----                                              |
|     x x                                               |
|      0 1                                              |
|                                                       |
|o5 : first order deformation space of dimension 1      |
+-------------------------------------------------------+
|i6 : isNonzero f                                       |
|                                                       |
|o6 = true                                              |
+-------------------------------------------------------+
|i7 : f1=firstOrderDeformation(mg, vector {-1,-1,2,0,0})|
|                                                       |
|       2                                               |
|      x                                                |
|       2                                               |
|o7 = ----                                              |
|     x x                                               |
|      0 1                                              |
|                                                       |
|o7 : first order deformation space of dimension 0      |
+-------------------------------------------------------+
|i8 : isNonzero f1                                      |
|                                                       |
|o8 = false                                             |
+-------------------------------------------------------+

See also
========

  * dim (Macaulay2Doc) -- compute the Krull dimension
  * isTrivial -- Check whether a deformation is trivial.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use isNonzero:
======================

  * "isNonzero(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4750:0.

isPolytope -- Check whether a complex is a polytope.
****************************************************

  * Usage:
        isPolytope(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Check whether a complex C is a polytope.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5];                                                      |
+--------------------------------------------------------------------------+
|i2 : C=fullCyclicPolytope(3,R)                                            |
|                                                                          |
|o2 = 3: x x x x x x                                                       |
|         0 1 2 3 4 5                                                      |
|                                                                          |
|o2 : complex of dim 3 embedded in dim 3 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : isPolytope C                                                         |
|                                                                          |
|o3 = true                                                                 |
+--------------------------------------------------------------------------+

Ways to use isPolytope:
=======================

  * "isPolytope(Complex)"
  * "isPolytope(List)"

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

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

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

The source of this document is in SRdeformations.m2:6308:0.

isSimp -- Check whether a complex or co-complex is simplicial.
**************************************************************

  * Usage:
        isSimp(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Check whether a complex or co-complex is simplicial.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                         |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                          |
|                                                                            |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x              |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5             |
|                                                                            |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1|
+----------------------------------------------------------------------------+
|i3 : isSimp C                                                               |
|                                                                            |
|o3 = true                                                                   |
+----------------------------------------------------------------------------+
|i4 : R=QQ[x_0..x_5]                                                         |
|                                                                            |
|o4 = R                                                                      |
|                                                                            |
|o4 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i5 : C1=fullCyclicPolytope(3,R)                                             |
|                                                                            |
|o5 = 3: x x x x x x                                                         |
|         0 1 2 3 4 5                                                        |
|                                                                            |
|o5 : complex of dim 3 embedded in dim 3 (printing facets)                   |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0  |
+----------------------------------------------------------------------------+
|i6 : isSimp C1                                                              |
|                                                                            |
|o6 = false                                                                  |
+----------------------------------------------------------------------------+

See also
========

  * boundaryCyclicPolytope -- The boundary
    complex of a cyclic polytope.
  * fullCyclicPolytope -- Cyclic polytope.

Ways to use isSimp:
===================

  * "isSimp(Complex)"
  * "isSimp(List)"

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

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

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

The source of this document is in SRdeformations.m2:7067:0.

isSubface -- Checks whether a face is a subface of another face.
****************************************************************

  * Usage:
        isSubface(F,G)
  * Inputs:
      * F, a face,
      * G, a face,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether F is a subface of G.

+-------------------------+
|i1 : R=QQ[x_0..x_4];     |
+-------------------------+
|i2 : C=simplex R;        |
+-------------------------+
|i3 : G=C.fc_3_0          |
|                         |
|o3 = x x x x             |
|      0 1 2 3            |
|                         |
|o3 : face with 4 vertices|
+-------------------------+
|i4 : F=C.fc_2_0          |
|                         |
|o4 = x x x               |
|      0 1 2              |
|                         |
|o4 : face with 3 vertices|
+-------------------------+
|i5 : H=C.fc_3_3          |
|                         |
|o5 = x x x x             |
|      0 2 3 4            |
|                         |
|o5 : face with 4 vertices|
+-------------------------+
|i6 : isSubface(F,G)      |
|                         |
|o6 = true                |
+-------------------------+
|i7 : isSubface(F,H)      |
|                         |
|o7 = false               |
+-------------------------+

Ways to use isSubface:
======================

  * "isSubface(Face,Face)"

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

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

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

The source of this document is in SRdeformations.m2:5782:0.

isTrivial -- Check whether a deformation is trivial.
****************************************************

  * Usage:
        isTrivial(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Check whether f is trivial, i.e., see denominatorMonomial,
f has degree 1.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : isTrivial f                                      |
|                                                      |
|o6 = false                                            |
+------------------------------------------------------+
|i7 : f1=firstOrderDeformation(mg, vector {-1,1,0,0,0})|
|                                                      |
|     x                                                |
|      1                                               |
|o7 = --                                               |
|     x                                                |
|      0                                               |
|                                                      |
|o7 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i8 : isTrivial f1                                     |
|                                                      |
|o8 = true                                             |
+------------------------------------------------------+

See also
========

  * isNonzero -- Check whether a deformation is non-zero.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.
  * trivialDeformations -- Compute the trivial
    deformations.

Ways to use isTrivial:
======================

  * "isTrivial(FirstOrderDeformation)"
  * "isTrivial(Vector)"

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

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

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

The source of this document is in SRdeformations.m2:4786:0.

iszero -- Tests whether something is zero.
******************************************

  * Usage:
        iszero(c)
  * Inputs:
      * c, a thing (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Makes the test c == 0_See class (Macaulay2Doc), c. Why does zero (Macaulay2Doc),
not work for elements in the cokernel of a matrix?

+--------------------------------------------------------------+
|i1 : A= matrix {{-1, -1, -1}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}|
|                                                              |
|o1 = | -1 -1 -1 |                                             |
|     | 1  0  0  |                                             |
|     | 0  1  0  |                                             |
|     | 0  0  1  |                                             |
|                                                              |
|              4       3                                       |
|o1 : Matrix ZZ  <-- ZZ                                        |
+--------------------------------------------------------------+
|i2 : c1=cokerElement(vector {1,1,0,0},A)                      |
|                                                              |
|o2 = | 2 |                                                    |
|     | 0 |                                                    |
|     | 0 |                                                    |
|     | 0 |                                                    |
|                                                              |
|o2 : Vector                                                   |
+--------------------------------------------------------------+
|i3 : c2=cokerElement(vector {1,-1,0,0},A)                     |
|                                                              |
|o3 = 0                                                        |
|                                                              |
|o3 : Vector                                                   |
+--------------------------------------------------------------+
|i4 : c2==(0_(class c2))                                       |
|                                                              |
|o4 = true                                                     |
+--------------------------------------------------------------+
|i5 : iszero c2                                                |
|                                                              |
|o5 = true                                                     |
+--------------------------------------------------------------+
|i6 : iszero c1                                                |
|                                                              |
|o6 = false                                                    |
+--------------------------------------------------------------+

See also
========

  * zero (Macaulay2Doc) -- whether something is zero
  * cokerElement -- Gives an element in the cokernel of a
    matrix.

Ways to use iszero:
===================

  * "iszero(Thing)"

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

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

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

The source of this document is in SRdeformations.m2:4064:0.

joinVectors -- Converts a list of vectors to a matrix.
******************************************************

  * Usage:
        joinVectors(C)
  * Inputs:
      * L, a list (Macaulay2Doc), of Vector (Macaulay2Doc),
        s
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Puts the vectors in a list into a matrix.

+---------------------------------------------------------+
|i1 : joinVectors {vector {1,2},vector {3,4},vector {5,6}}|
|                                                         |
|o1 = | 1 3 5 |                                           |
|     | 2 4 6 |                                           |
|                                                         |
|              2       3                                  |
|o1 : Matrix ZZ  <-- ZZ                                   |
+---------------------------------------------------------+

Ways to use joinVectors:
========================

  * "joinVectors(List)"

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

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

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

The source of this document is in SRdeformations.m2:7464:0.

laurent -- Converts an exponent vector or a deformation into a Laurent monomial.
********************************************************************************

  * Usage:
        laurent(v,R)
        laurent(f)
  * Inputs:
      * v, a vector (Macaulay2Doc),
      * f, a first order deformation,
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc),

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

Converts the exponent vector v into a Laurent monomial in the variables of R.
The result lies in frac (Macaulay2Doc), R. The number of variables
of R has to match the length of v.

If given a FirstOrderDeformation, it returns the
corresponding laurent monomial.

+--------------------------+
|i1 : R=QQ[x_0..x_4]       |
|                          |
|o1 = R                    |
|                          |
|o1 : PolynomialRing       |
+--------------------------+
|i2 : m=vector {1,-2,1,0,0}|
|                          |
|o2 = |  1 |               |
|     | -2 |               |
|     |  1 |               |
|     |  0 |               |
|     |  0 |               |
|                          |
|       5                  |
|o2 : ZZ                   |
+--------------------------+
|i3 : laurent(m,R)         |
|                          |
|     x x                  |
|      0 2                 |
|o3 = ----                 |
|       2                  |
|      x                   |
|       1                  |
|                          |
|o3 : frac R               |
+--------------------------+

+------------------------------------------------------+
|i4 : R=QQ[x_0..x_4]                                   |
|                                                      |
|o4 = R                                                |
|                                                      |
|o4 : PolynomialRing                                   |
+------------------------------------------------------+
|i5 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o5 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i6 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o6 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o6 : Ideal of R                                       |
+------------------------------------------------------+
|i7 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o7 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i8 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o8 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o8 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i9 : laurent f                                        |
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o9 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o9 : frac R                                           |
+------------------------------------------------------+

See also
========

  * laurent -- Converts an exponent vector or a deformation
    into a Laurent monomial.

Ways to use laurent:
====================

  * "laurent(FirstOrderDeformation)"
  * "laurent(Vector,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:4133:0.

link -- The link of a face of a complex.
****************************************

  * Usage:
        link(F)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

The link of the face F of the complex C.

+---------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                        |
|                                                                           |
|o1 = R                                                                     |
|                                                                           |
|o1 : PolynomialRing                                                        |
+---------------------------------------------------------------------------+
|i2 : C=boundaryOfPolytope simplex(R)                                       |
|                                                                           |
|o2 = 3: x x x x  x x x x  x x x x  x x x x  x x x x                        |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4  1 2 3 4                       |
|                                                                           |
|o2 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 0}, Euler = -1|
+---------------------------------------------------------------------------+
|i3 : F=C.fc_0_0                                                            |
|                                                                           |
|o3 = x                                                                     |
|      0                                                                    |
|                                                                           |
|o3 : face with 1 vertex                                                    |
+---------------------------------------------------------------------------+
|i4 : link(F,C)                                                             |
|                                                                           |
|o4 = 2: x x x  x x x  x x x  x x x                                         |
|         1 2 3  1 2 4  1 3 4  2 3 4                                        |
|                                                                           |
|o4 : complex of dim 2 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 4, 6, 4, 0, 0}, Euler = 1   |
+---------------------------------------------------------------------------+
|i5 : closedStar(F,C)                                                       |
|                                                                           |
|o5 = 3: x x x x  x x x x  x x x x  x x x x                                 |
|         0 1 2 3  0 1 2 4  0 1 3 4  0 2 3 4                                |
|                                                                           |
|o5 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 4, 0}, Euler = 0 |
+---------------------------------------------------------------------------+
|i6 : F=C.fc_1_0                                                            |
|                                                                           |
|o6 = x x                                                                   |
|      0 1                                                                  |
|                                                                           |
|o6 : face with 2 vertices                                                  |
+---------------------------------------------------------------------------+
|i7 : link(F,C)                                                             |
|                                                                           |
|o7 = 1: x x  x x  x x                                                      |
|         2 3  2 4  3 4                                                     |
|                                                                           |
|o7 : complex of dim 1 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 3, 3, 0, 0, 0}, Euler = -1  |
+---------------------------------------------------------------------------+
|i8 : closedStar(F,C)                                                       |
|                                                                           |
|o8 = 3: x x x x  x x x x  x x x x                                          |
|         0 1 2 3  0 1 2 4  0 1 3 4                                         |
|                                                                           |
|o8 : complex of dim 3 embedded in dim 4 (printing facets)                  |
|     equidimensional, simplicial, F-vector {1, 5, 10, 9, 3, 0}, Euler = 0  |
+---------------------------------------------------------------------------+

+--------------------------------------------------------------------------+
|i9 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o9 = R                                                                    |
|                                                                          |
|o9 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i10 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                          |
|o10 = ideal (x x , x x , x x , x x , x x )                                |
|              0 1   1 2   2 3   3 4   0 4                                 |
|                                                                          |
|o10 : Ideal of R                                                          |
+--------------------------------------------------------------------------+
|i11 : C=idealToComplex I                                                  |
|                                                                          |
|o11 = 1: x x  x x  x x  x x  x x                                          |
|          0 2  0 3  1 3  1 4  2 4                                         |
|                                                                          |
|o11 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+
|i12 : F=C.fc_0_0                                                          |
|                                                                          |
|o12 = x                                                                   |
|       0                                                                  |
|                                                                          |
|o12 : face with 1 vertex                                                  |
+--------------------------------------------------------------------------+
|i13 : link(F,C)                                                           |
|                                                                          |
|o13 = 0: x  x                                                             |
|          2  3                                                            |
|                                                                          |
|o13 : complex of dim 0 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 2, 0, 0, 0, 0}, Euler = 1 |
+--------------------------------------------------------------------------+
|i14 : closedStar(F,C)                                                     |
|                                                                          |
|o14 = 1: x x  x x                                                         |
|          0 2  0 3                                                        |
|                                                                          |
|o14 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 3, 2, 0, 0, 0}, Euler = 0 |
+--------------------------------------------------------------------------+
|i15 : F=C.fc_1_0                                                          |
|                                                                          |
|o15 = x x                                                                 |
|       0 2                                                                |
|                                                                          |
|o15 : face with 2 vertices                                                |
+--------------------------------------------------------------------------+
|i16 : link(F,C)                                                           |
|                                                                          |
|o16 = -1: {}                                                              |
|                                                                          |
|o16 : complex of dim -1 embedded in dim 4 (printing facets)               |
|      equidimensional, simplicial, F-vector {1, 0, 0, 0, 0, 0}, Euler = -1|
+--------------------------------------------------------------------------+
|i17 : closedStar(F,C)                                                     |
|                                                                          |
|o17 = 1: x x                                                              |
|          0 2                                                             |
|                                                                          |
|o17 : complex of dim 1 embedded in dim 4 (printing facets)                |
|      equidimensional, simplicial, F-vector {1, 2, 1, 0, 0, 0}, Euler = 0 |
+--------------------------------------------------------------------------+

See also
========

  * closedStar -- The closed star of a face of a complex.

Ways to use link:
=================

  * "link(Face,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:5943:0.

loadDeformations -- Read the deformation data of a complex from a file.
***********************************************************************

  * Usage:
        loadDeformations(C,fn)
  * Inputs:
      * C, an embedded complex,
      * fn, a string (Macaulay2Doc), file name.
  * Outputs:
      * an embedded complex,

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

Read the deformation data of a complex C from a file with name fn.

The deformations are stored in C.deform.

Caveat
======

This does not change deformation data which may be stored in the individual
faces.

See also
========

  * saveDeformations -- Store the deformation data of
    a complex in a file.
  * deform -- Compute the deformations associated to a
    Stanley-Reisner complex.

Ways to use loadDeformations:
=============================

  * "loadDeformations(Complex,String)"

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

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

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

The source of this document is in SRdeformations.m2:7852:0.

minimalNonFaces -- The minimal non-faces of a complex.
******************************************************

  * Usage:
        minimalNonFaces(C)
  * Inputs:
      * C, an embedded complex,
  * Optional inputs (Macaulay2Doc),:
      * embedded, => ..., default value null, Use only faces of
        the embedding complex.
  * Outputs:
      * a list (Macaulay2Doc),

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

The minimal non-faces of a complex. All subsets of the variables of
simplexRing,(C) are tested as standard.

If the option embedded=>true is specified then only faces of
embeddingComplex,(C) are tested.

+-------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                     |
+-------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0);                   |
|                                                                         |
|o2 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i3 : C=idealToComplex I                                                  |
|                                                                         |
|o3 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o3 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i4 : minimalNonFaces C                                                   |
|                                                                         |
|o4 = {x x , x x , x x , x x , x x }                                      |
|       0 1   1 2   2 3   0 4   3 4                                       |
|                                                                         |
|o4 : List                                                                |
+-------------------------------------------------------------------------+

See also
========

  * idealToComplex -- The complex associated to a
    reduced monomial ideal.
  * complexToIdeal -- The monomial ideal associated to a
    complex.
  * embeddingComplex -- The embedding complex of a
    complex or co-complex.

Ways to use minimalNonFaces:
============================

  * "minimalNonFaces(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7497:0.

mirrorSphere -- Example how to compute the mirror sphere.
*********************************************************

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

Example how to compute the mirror sphere as an Complex.

This is work in progress. Many interesting pieces are not yet implemented.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                          |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_2*x_3*x_4)                                            |
|                                                                             |
|o2 = ideal (x x , x x x )                                                    |
|             0 1   2 3 4                                                     |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : C=idealToComplex I                                                      |
|                                                                             |
|o3 = 2: x x x  x x x  x x x  x x x  x x x  x x x                             |
|         0 2 3  1 2 3  0 2 4  1 2 4  0 3 4  1 3 4                            |
|                                                                             |
|o3 : complex of dim 2 embedded in dim 4 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 5, 9, 6, 0, 0}, Euler = 1     |
+-----------------------------------------------------------------------------+
|i4 : PT1C=PT1 C                                                              |
|                                                                             |
|o4 = 4: y y y y y y y y y y                                                  |
|         0 1 2 3 4 5 6 7 8 9                                                 |
|                                                                             |
|o4 : complex of dim 4 embedded in dim 4 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 10, 24, 25, 11, 1}, Euler |
|-----------------------------------------------------------------------------|
|= 0                                                                          |
+-----------------------------------------------------------------------------+
|i5 : tropDefC=tropDef(C,PT1C)                                                |
|                                                                             |
|o5 = 1: y y  y y  y y  y y  y y                                              |
|         0 4  8 9  3 7  2 6  1 5                                             |
|                                                                             |
|o5 : co-complex of dim 1 embedded in dim 4 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {0, 0, 5, 9, 6, 1}, Euler = -1|
+-----------------------------------------------------------------------------+
|i6 : tropDefC.grading                                                        |
|                                                                             |
|o6 = | -1 0  0  0  |                                                         |
|     | 1  0  0  0  |                                                         |
|     | -1 2  0  0  |                                                         |
|     | -1 0  2  0  |                                                         |
|     | 0  -1 -1 -1 |                                                         |
|     | 3  -1 -1 -1 |                                                         |
|     | 0  2  -1 -1 |                                                         |
|     | 0  -1 2  -1 |                                                         |
|     | -1 0  0  2  |                                                         |
|     | 0  -1 -1 2  |                                                         |
|                                                                             |
|              10       4                                                     |
|o6 : Matrix ZZ   <-- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i7 : B=dualize tropDefC                                                      |
|                                                                             |
|o7 = 2: v v v  v v v v  v v v v  v v v v  v v v                              |
|         2 4 7  2 4 8 9  2 5 7 9  4 5 7 8  5 8 9                             |
|                                                                             |
|o7 : complex of dim 2 embedded in dim 4 (printing facets)                    |
|     equidimensional, non-simplicial, F-vector {1, 6, 9, 5, 0, 0}, Euler = 1 |
+-----------------------------------------------------------------------------+
|i8 : B.grading                                                               |
|                                                                             |
|o8 = | 1  0  0  0  |                                                         |
|     | 0  1  0  0  |                                                         |
|     | 1  1  0  0  |                                                         |
|     | 0  0  1  0  |                                                         |
|     | 1  0  1  0  |                                                         |
|     | -1 -1 -1 0  |                                                         |
|     | 0  0  0  1  |                                                         |
|     | 1  0  0  1  |                                                         |
|     | -1 -1 0  -1 |                                                         |
|     | -1 0  -1 -1 |                                                         |
|     | -1 -1 -1 -1 |                                                         |
|                                                                             |
|              11       4                                                     |
|o8 : Matrix QQ   <-- QQ                                                      |
+-----------------------------------------------------------------------------+
|i9 : fvector C                                                               |
|                                                                             |
|o9 = {1, 5, 9, 6, 0, 0}                                                      |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : fvector B                                                              |
|                                                                             |
|o10 = {1, 6, 9, 5, 0, 0}                                                     |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

The implementation of testing whether a face is tropical so far uses a trick to
emulate higher order. For very complicated (non-complete intersections and
non-Pfaffians) examples this may lead to an incorrect result. Use with care.
This will be fixed at some point.

If using Polyhedra, to compute convex hulls and its faces
instead of ConvexInterface you are limited to rather simple examples.

See also
========

  * PT1 -- Compute the deformation polytope associated to a
    Stanley-Reisner complex.
  * tropDef -- The co-complex of tropical faces of the
    deformation polytope.
  * HH Complex -- Compute the homology of a complex.

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

The object mirrorSphere, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:7730:0.

net(Complex) -- Printing complexes.
***********************************

  * Function: net (Macaulay2Doc),
  * Usage:
        net(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a net (Macaulay2Doc),

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

Printing complexes. It prints the facets, of the complex C sorted
by dimension.

+-----------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                  |
|                                                     |
|o1 = R                                               |
|                                                     |
|o1 : PolynomialRing                                  |
+-----------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)|
|                                                     |
|o2 = ideal (x x , x x , x x , x x , x x )            |
|             0 1   1 2   2 3   3 4   0 4             |
|                                                     |
|o2 : Ideal of R                                      |
+-----------------------------------------------------+
|i3 : C=idealToComplex I;                             |
+-----------------------------------------------------+
|i4 : net C                                           |
|                                                     |
|o4 = 1: x x  x x  x x  x x  x x                      |
|         0 2  0 3  1 3  1 4  2 4                     |
+-----------------------------------------------------+

See also
========

  * net (Macaulay2Doc) -- format for printing, as a net

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

  * net(Complex) -- Printing complexes.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:7307:0.

net(Face) -- Printing faces.
****************************

  * Function: net (Macaulay2Doc),
  * Usage:
        net(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * a net (Macaulay2Doc),

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

Prints a face. The vertices are printed without any brackets. The number of
vertices is printed.

+-------------------------+
|i1 : R=QQ[x_0..x_4];     |
+-------------------------+
|i2 : C=simplex R;        |
+-------------------------+
|i3 : F=C.fc_2_0          |
|                         |
|o3 = x x x               |
|      0 1 2              |
|                         |
|o3 : face with 3 vertices|
+-------------------------+

See also
========

  * net (Macaulay2Doc) -- format for printing, as a net

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

  * net(Face) -- Printing faces.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5727:0.

net(FirstOrderDeformation) -- Pretty print for deformations.
************************************************************

  * Function: net (Macaulay2Doc),
  * Usage:
        net(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a net (Macaulay2Doc),

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

Pretty print for deformations. Prints laurent, f and
dim(FirstOrderDeformation), f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                   |
|                                                      |
|o1 = R                                                |
|                                                      |
|o1 : PolynomialRing                                   |
+------------------------------------------------------+
|i2 : addCokerGrading(R)                               |
|                                                      |
|o2 = | -1 -1 -1 -1 |                                  |
|     | 1  0  0  0  |                                  |
|     | 0  1  0  0  |                                  |
|     | 0  0  1  0  |                                  |
|     | 0  0  0  1  |                                  |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+

See also
========

  * Net (Macaulay2Doc) -- the class of all nets and strings
  * net (Macaulay2Doc) -- format for printing, as a net

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

  * net(FirstOrderDeformation) -- Pretty
    print for deformations.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4814:0.

newEmptyComplex -- Generates an empty complex.
**********************************************

  * Usage:
        newEmptyComplex(R)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), with coker
        grading added by addCokerGrading,
  * Outputs:
      * C, an embedded complex,

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

Generates an empty complex. Face and facet data or just facet
data can be added later by addFaceDataToComplex, or
addFacetDataToComplex.

This function is mainly used internally to create an empty complex data
structure to be filled later, but may occasionally be useful to the user and is
hence exported.

+-------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                      |
|                                                                         |
|o1 = R                                                                   |
|                                                                         |
|o1 : PolynomialRing                                                      |
+-------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                  |
|                                                                         |
|o2 = | -1 -1 -1 -1 |                                                     |
|     | 1  0  0  0  |                                                     |
|     | 0  1  0  0  |                                                     |
|     | 0  0  1  0  |                                                     |
|     | 0  0  0  1  |                                                     |
|                                                                         |
|              5       4                                                  |
|o2 : Matrix ZZ  <-- ZZ                                                   |
+-------------------------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                    |
|                                                                         |
|o3 = ideal (x x , x x , x x , x x , x x )                                |
|             0 1   1 2   2 3   3 4   0 4                                 |
|                                                                         |
|o3 : Ideal of R                                                          |
+-------------------------------------------------------------------------+
|i4 : C=idealToComplex(I)                                                 |
|                                                                         |
|o4 = 1: x x  x x  x x  x x  x x                                          |
|         0 2  0 3  1 3  1 4  2 4                                         |
|                                                                         |
|o4 : complex of dim 1 embedded in dim 4 (printing facets)                |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1|
+-------------------------------------------------------------------------+
|i5 : Cl=newEmptyComplex(R)                                               |
|                                                                         |
|o5 = empty complex                                                       |
|                                                                         |
|o5 : complex of dim -1 embedded in dim 4 (printing facets)               |
|     equidimensional, simplicial                                         |
+-------------------------------------------------------------------------+
|i6 : addFacetDataToComplex(Cl,facets C)                                  |
|                                                                         |
|o6 = done                                                                |
+-------------------------------------------------------------------------+
|i7 : Cl==C                                                               |
|                                                                         |
|o7 = true                                                                |
+-------------------------------------------------------------------------+

See also
========

  * addFaceDataToComplex -- Adds to a complex face
    data.
  * addFacetDataToComplex -- Adds to a complex
    facet data.
  * dim (Macaulay2Doc) -- compute the Krull dimension
  * fvector -- The F-vector of a complex.
  * facets -- The maximal faces of a complex.
  * isSimp -- Check whether a complex or co-complex is
    simplicial.
  * isEquidimensional -- Check whether a complex or
    co-complex is equidimensional.

Ways to use newEmptyComplex:
============================

  * "newEmptyComplex(PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:7281:0.

noBoundary -- Optional data of Complex.
***************************************

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

Optional data in the MutableHashTable (Macaulay2Doc),
Complex, indicating whether the complex has no relative
boundary.

See also
========

  * Complex -- The class of all embedded complexes.
  * CoComplex -- The class of all embedded co-complexes.

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

The object noBoundary, is a symbol (Macaulay2Doc).

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

The source of this document is in SRdeformations.m2:6743:0.

numerator(FirstOrderDeformation) -- The numerator of a deformation as a vector.
*******************************************************************************

  * Function: numerator (Macaulay2Doc),
  * Usage:
        numerator(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a vector (Macaulay2Doc),

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

Returns the numerator of a deformation as a vector.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : numerator f                                      |
|                                                      |
|o6 = | 0 |                                            |
|     | 0 |                                            |
|     | 0 |                                            |
|     | 2 |                                            |
|     | 0 |                                            |
|                                                      |
|       5                                              |
|o6 : ZZ                                               |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * numeratorMonomial -- The numerator monomial of a
    deformation.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4458:0.

numeratorMonomial -- The numerator monomial of a deformation.
*************************************************************

  * Usage:
        numeratorMonomial(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a ring element (Macaulay2Doc),

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

Returns the numerator monomial of a deformation.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : numeratorMonomial f                              |
|                                                      |
|      2                                               |
|o6 = x                                                |
|      3                                               |
|                                                      |
|o6 : R                                                |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * denominatorMonomial -- The denominator monomial
    of a deformation.
  * denominator(FirstOrderDeformation)
    -- The denominator of a deformation
    as a vector.
  * numerator(FirstOrderDeformation)
    -- The numerator of a deformation as
    a vector.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use numeratorMonomial:
==============================

  * "numeratorMonomial(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4524:0.

ofComplex -- The complex of a face.
***********************************

  * Usage:
        ofComplex(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * an embedded complex,

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

Returns the complex of F, i.e., the first entry in F.ofComplex.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                      |
+--------------------------------------------------------------------------+
|i2 : C=simplex R                                                          |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : F=C.fc_2_0                                                           |
|                                                                          |
|o3 = x x x                                                                |
|      0 1 2                                                               |
|                                                                          |
|o3 : face with 3 vertices                                                 |
+--------------------------------------------------------------------------+
|i4 : ofComplex F                                                          |
|                                                                          |
|o4 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o4 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+

See also
========

  * indices(Face) -- The indices of a face.

Ways to use ofComplex:
======================

  * "ofComplex(Face)"

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

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

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

The source of this document is in SRdeformations.m2:5574:0.

parameters -- Parameters of a deformation.
******************************************

  * Usage:
        parameters(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Computes a matrix (Macaulay2Doc), whose columns correspond to the
parameters of f (i.e., to the coefficients of the image (Macaulay2Doc),
s of the generators (Macaulay2Doc), of
source(FirstOrderDeformation), f
considering it as a homomorphism.

+-----------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                 |
+-----------------------------------------------------+
|i2 : addCokerGrading(R);                             |
|                                                     |
|              5       4                              |
|o2 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)|
|                                                     |
|o3 = ideal (x x , x x , x x , x x , x x )            |
|             0 1   1 2   2 3   3 4   0 4             |
|                                                     |
|o3 : Ideal of R                                      |
+-----------------------------------------------------+
|i4 : mg=mingens I;                                   |
|                                                     |
|             1      5                                |
|o4 : Matrix R  <-- R                                 |
+-----------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,1,0,0,0})|
|                                                     |
|     x                                               |
|      1                                              |
|o5 = --                                              |
|     x                                               |
|      0                                              |
|                                                     |
|o5 : first order deformation space of dimension 1    |
+-----------------------------------------------------+
|i6 : relationsCoefficients f                         |
|                                                     |
|o6 = | -1 |                                          |
|     | 1  |                                          |
|                                                     |
|              2       1                              |
|o6 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+
|i7 : parameters f                                    |
|                                                     |
|o7 = | 0 |                                           |
|     | 1 |                                           |
|     | 0 |                                           |
|     | 0 |                                           |
|     | 1 |                                           |
|                                                     |
|              5       1                              |
|o7 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+

See also
========

  * dim(FirstOrderDeformation), --
    Compute the dimension of a deformation.
  * relationsCoefficients -- Relations between
    the coefficients of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use parameters:
=======================

  * "parameters(FirstOrderDeformation)"
  * "parameters(Matrix,Vector)"

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

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

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

The source of this document is in SRdeformations.m2:4989:0.

polytopalFacets -- The facets of a polytope.
********************************************

  * Usage:
        polytopalFacets(C)
  * Inputs:
      * C, an embedded complex, a polytope
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * C, an embedded complex,

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

The facets of a polytope. Note that this is not facets(C) (which is the
polytope itself).

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : C=fullCyclicPolytope(3,R)                                            |
|                                                                          |
|o2 = 3: x x x x x x                                                       |
|         0 1 2 3 4 5                                                      |
|                                                                          |
|o2 : complex of dim 3 embedded in dim 3 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {1, 6, 12, 8, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : facets C                                                             |
|                                                                          |
|o3 = {{}, {}, {}, {}, {x x x x x x }}                                     |
|                        0 1 2 3 4 5                                       |
|                                                                          |
|o3 : List                                                                 |
+--------------------------------------------------------------------------+
|i4 : polytopalFacets(C)                                                   |
|                                                                          |
|o4 = {x x x , x x x , x x x , x x x , x x x , x x x , x x x , x x x }     |
|       0 1 2   0 2 3   0 3 4   0 1 5   1 2 5   2 3 5   0 4 5   3 4 5      |
|                                                                          |
|o4 : List                                                                 |
+--------------------------------------------------------------------------+

See also
========

  * isPolytope -- Check whether a complex is a polytope.
  * facets -- The maximal faces of a complex.

Ways to use polytopalFacets:
============================

  * "polytopalFacets(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6255:0.

possibleDenominators -- Possible denominators of deformations.
**************************************************************

  * Usage:
        possibleDenominators(I)
        possibleDenominators(I,v)
  * Inputs:
      * I, an ideal (Macaulay2Doc), monomial, reduced.
      * v, a list (Macaulay2Doc), of variables of ring (Macaulay2Doc),
        I.
  * Outputs:
      * L, a list (Macaulay2Doc),

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

Computes a list L of possible denominators of Laurent monomials representing
FirstOrderDeformation,s of I. The list L is
stratified into lists with ascending degree of the denominators. Each
denominator is represented as a list of variables.

If the second argument v is given, one obtains only denominators contained (as
a list) in v.

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                         |
+-----------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0);                       |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : possibleDenominators(I)                                                 |
|                                                                             |
|o3 = {{{x }, {x }, {x }, {x }, {x }}, {{x , x }, {x , x }, {x , x }, {x ,    |
|         0     1     2     3     4       0   1     1   2     2   3     0     |
|     ------------------------------------------------------------------------|
|     x }, {x , x }}}                                                         |
|      4     3   4                                                            |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : possibleDenominators(I,{x_0,x_1,x_2});                                  |
+-----------------------------------------------------------------------------+

See also
========

  * deformationsFace -- Compute the deformations
    associated to a face.
  * deform -- Compute the deformations associated to a
    Stanley-Reisner complex.

Ways to use possibleDenominators:
=================================

  * "possibleDenominators(Ideal)"
  * "possibleDenominators(Ideal,List)"
  * "possibleDenominators(List,List)"

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

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

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

The source of this document is in SRdeformations.m2:7536:0.

preImage -- Compute the preimage.
*********************************

  * Usage:
        preImage(A,v)
  * Inputs:
      * A, a matrix (Macaulay2Doc), of full rank.
      * v, a vector (Macaulay2Doc), in target (Macaulay2Doc),
        A.
  * Outputs:
      * a vector (Macaulay2Doc), in source (Macaulay2Doc),
        A.

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

Computes the preimage of v under A. If v is not in image (Macaulay2Doc),
A then returns false.

+----------------------------------------+
|i1 : A=matrix {{1, 0}, {0, 1}, {-1, -1}}|
|                                        |
|o1 = | 1  0  |                          |
|     | 0  1  |                          |
|     | -1 -1 |                          |
|                                        |
|              3       2                 |
|o1 : Matrix ZZ  <-- ZZ                  |
+----------------------------------------+
|i2 : b=vector {-2,2,0}                  |
|                                        |
|o2 = | -2 |                             |
|     |  2 |                             |
|     |  0 |                             |
|                                        |
|       3                                |
|o2 : ZZ                                 |
+----------------------------------------+
|i3 : v=preImage(A,b)                    |
|                                        |
|o3 = | -2 |                             |
|     |  2 |                             |
|                                        |
|       2                                |
|o3 : ZZ                                 |
+----------------------------------------+
|i4 : A*v                                |
|                                        |
|o4 = | -2 |                             |
|     |  2 |                             |
|     |  0 |                             |
|                                        |
|       3                                |
|o4 : ZZ                                 |
+----------------------------------------+

Ways to use preImage:
=====================

  * "preImage(Matrix,Vector)"

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

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

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

The source of this document is in SRdeformations.m2:7564:0.

PT1 -- Compute the deformation polytope associated to a Stanley-Reisner complex.
********************************************************************************

  * Usage:
        PT1(C)
  * Inputs:
      * C, an embedded complex,
  * Optional inputs (Macaulay2Doc),:
      * file, => ..., default value null, Store result of a
        computation in a file.
  * Outputs:
      * an embedded complex,

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

Compute the deformation polytope of C, i.e., the convex hull of all homogeneous
(i.e., see degree(FirstOrderDeformation),
zero) deformations associated to C, considering them as lattice monomials
(i.e., their preimages under C.grading).

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_3]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_2*x_3)                                             |
|                                                                          |
|o2 = ideal (x x , x x )                                                   |
|             0 1   2 3                                                    |
|                                                                          |
|o2 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i3 : C=idealToComplex I                                                   |
|                                                                          |
|o3 = 1: x x  x x  x x  x x                                                |
|         0 2  1 2  0 3  1 3                                               |
|                                                                          |
|o3 : complex of dim 1 embedded in dim 3 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 4, 4, 0, 0}, Euler = -1    |
+--------------------------------------------------------------------------+
|i4 : PT1C=PT1 C                                                           |
|                                                                          |
|o4 = 3: y y y y y y y y                                                   |
|         0 1 2 3 4 5 6 7                                                  |
|                                                                          |
|o4 : complex of dim 3 embedded in dim 3 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {1, 8, 14, 8, 1}, Euler = 0|
+--------------------------------------------------------------------------+

Caveat
======

To homogenize the denominators of deformations (which are supported inside the
link) we use globalSections to deal with the toric case. The speed of this
should be improved. For ordinary projective space homogenization with support
on F is done much faster.

See also
========

  * deformationsFace -- Compute the deformations
    associated to a face.
  * link -- The link of a face of a complex.
  * globalSections -- The global sections of a toric
    divisor.
  * tropDef -- The co-complex of tropical faces of the
    deformation polytope.

Ways to use PT1:
================

  * "PT1(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7645:0.

raysPPn -- The rays of the standard fan of projective space or weighted projective space.
*****************************************************************************************

  * Usage:
        raysPPn(n)
  * Inputs:
      * n, an integer (Macaulay2Doc), positive
      * L, a list (Macaulay2Doc), with at least 2 elements and
        first entry 1
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Returns a matrix which has in its rows the rays of the standard fan of
projective space of dimension n or weighted projective space with the weights
L.

+-----------------------+
|i1 : raysPPn(2)        |
|                       |
|o1 = | -1 -1 |         |
|     | 1  0  |         |
|     | 0  1  |         |
|                       |
|              3       2|
|o1 : Matrix ZZ  <-- ZZ |
+-----------------------+

See also
========

  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use raysPPn:
====================

  * "raysPPn(List)"
  * "raysPPn(ZZ)"

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

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

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

The source of this document is in SRdeformations.m2:5175:0.

relationsCoefficients -- Relations between the coefficients of a deformation.
*****************************************************************************

  * Usage:
        relationsCoefficients(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Computes the matrix (Macaulay2Doc), whose columns generate the
relations on the coefficients of the image (Macaulay2Doc),s of the
generators (Macaulay2Doc), of
source(FirstOrderDeformation), f considering
it as a homomorphism.

+-----------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                 |
+-----------------------------------------------------+
|i2 : addCokerGrading(R);                             |
|                                                     |
|              5       4                              |
|o2 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)|
|                                                     |
|o3 = ideal (x x , x x , x x , x x , x x )            |
|             0 1   1 2   2 3   3 4   0 4             |
|                                                     |
|o3 : Ideal of R                                      |
+-----------------------------------------------------+
|i4 : mg=mingens I;                                   |
|                                                     |
|             1      5                                |
|o4 : Matrix R  <-- R                                 |
+-----------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,1,0,0,0})|
|                                                     |
|     x                                               |
|      1                                              |
|o5 = --                                              |
|     x                                               |
|      0                                              |
|                                                     |
|o5 : first order deformation space of dimension 1    |
+-----------------------------------------------------+
|i6 : relationsCoefficients f                         |
|                                                     |
|o6 = | -1 |                                          |
|     | 1  |                                          |
|                                                     |
|              2       1                              |
|o6 : Matrix ZZ  <-- ZZ                               |
+-----------------------------------------------------+

See also
========

  * source(FirstOrderDeformation), --
    The source of a deformation.
  * parameters -- Parameters of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use relationsCoefficients:
==================================

  * "relationsCoefficients(FirstOrderDeformation)"
  * "relationsCoefficients(Matrix,Vector)"

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

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

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

The source of this document is in SRdeformations.m2:4955:0.

saveDeformations -- Store the deformation data of a complex in a file.
**********************************************************************

  * Usage:
        saveDeformations(C,fn)
  * Inputs:
      * C, an embedded complex,
      * fn, a string (Macaulay2Doc), file name.
  * Outputs:
      * a list (Macaulay2Doc), with all
        FirstOrderDeformation,s.

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

Store the deformation data of a complex C in a file with name fn.

See also
========

  * loadDeformations -- Read the deformation data of a
    complex from a file.
  * deform -- Compute the deformations associated to a
    Stanley-Reisner complex.

Ways to use saveDeformations:
=============================

  * "saveDeformations(Complex,String)"

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

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

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

The source of this document is in SRdeformations.m2:7825:0.

simplex -- Simplex in the variables of a polynomial ring.
*********************************************************

  * Usage:
        simplex(R)
        simplex(R,Rdual)
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc),
      * Rdual, a polynomial ring (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * computeFaces, => ..., default value null, Compute
        faces of a simplex.
  * Outputs:
      * an embedded complex,

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

Returns a simplex on the variables of R.

If R does not have a coker grading then the standard projective space fan rays
are added, see addCokerGrading, and raysPPn.

The Option computeFaces=>false suppresses the computation of all faces.

If Rdual is specified it is used for the vertices of the dual simplex, if not a
new polynomial ring is created. It is graded by the coordinates of the vertices
of the dual simplex.

The dual simplex is always created without face data.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : C=simplex(R)                                                         |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : grading C                                                            |
|                                                                          |
|o3 = | -1 -1 -1 -1 |                                                      |
|     | 1  0  0  0  |                                                      |
|     | 0  1  0  0  |                                                      |
|     | 0  0  1  0  |                                                      |
|     | 0  0  0  1  |                                                      |
|                                                                          |
|              5       4                                                   |
|o3 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i4 : dC=C.dualComplex                                                     |
|                                                                          |
|o4 = 4: v v v v v                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o4 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial                                          |
+--------------------------------------------------------------------------+
|i5 : grading dC                                                           |
|                                                                          |
|o5 = | -1 -1 -1 4  |                                                      |
|     | -1 -1 4  -1 |                                                      |
|     | -1 4  -1 -1 |                                                      |
|     | 4  -1 -1 -1 |                                                      |
|     | -1 -1 -1 -1 |                                                      |
|                                                                          |
|              5       4                                                   |
|o5 : Matrix QQ  <-- QQ                                                    |
+--------------------------------------------------------------------------+
|i6 : fc(dC);                                                              |
+--------------------------------------------------------------------------+
|i7 : dC                                                                   |
|                                                                          |
|o7 = 4: v v v v v                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o7 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+

See also
========

  * grading -- The grading of a first order deformation or
    complex or polynomial ring.
  * dualGrading -- The dual vertices of a polytope.

Ways to use simplex:
====================

  * "simplex(PolynomialRing)"
  * "simplex(PolynomialRing,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:5987:0.

simplexDim -- The dimension of a face inside the vertex simplex.
****************************************************************

  * Usage:
        simplexDim(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * an integer (Macaulay2Doc), bigger or equal to -1

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

The dimension of a face inside the vertex simplex, i.e., the number of
vert, F minus 1.

+-------------------------+
|i1 : R=QQ[x_0..x_4];     |
+-------------------------+
|i2 : C=simplex R;        |
+-------------------------+
|i3 : F=C.fc_2_0          |
|                         |
|o3 = x x x               |
|      0 1 2              |
|                         |
|o3 : face with 3 vertices|
+-------------------------+
|i4 : simplexDim F        |
|                         |
|o4 = 2                   |
+-------------------------+

See also
========

  * vert -- The vertices of a face or complex.
  * dim(Face) -- Compute the dimension of a face.

Ways to use simplexDim:
=======================

  * "simplexDim(Face)"

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

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

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

The source of this document is in SRdeformations.m2:5756:0.

simplexRing -- The underlying polynomial ring of a deformation or face or complex.
**********************************************************************************

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

The underlying polynomial ring of a deformation or face or complex.

Ways to use simplexRing:
========================

  * simplexRing(Complex) -- The underlying
    polynomial ring of a complex.
  * simplexRing(Face) -- The underlying
    polynomial ring of a face.
  * simplexRing(FirstOrderDeformation)
    -- The underlying polynomial ring
    of a deformation or face.

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

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

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

The source of this document is in SRdeformations.m2:4309:0.

simplexRing(Complex) -- The underlying polynomial ring of a complex.
********************************************************************

  * Function: simplexRing,
  * Usage:
        simplexRing(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

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

The underlying polynomial ring of C.

+-----------------------+
|i1 : R=QQ[x_0..x_4];   |
+-----------------------+
|i2 : C=simplex R;      |
+-----------------------+
|i3 : simplexRing C     |
|                       |
|o3 = R                 |
|                       |
|o3 : PolynomialRing    |
+-----------------------+
|i4 : R.grading         |
|                       |
|o4 = | -1 -1 -1 -1 |   |
|     | 1  0  0  0  |   |
|     | 0  1  0  0  |   |
|     | 0  0  1  0  |   |
|     | 0  0  0  1  |   |
|                       |
|              5       4|
|o4 : Matrix ZZ  <-- ZZ |
+-----------------------+

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

  * simplexRing(Complex) -- The underlying
    polynomial ring of a complex.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5858:0.

simplexRing(Face) -- The underlying polynomial ring of a face.
**************************************************************

  * Function: simplexRing,
  * Usage:
        simplexRing(F)
  * Inputs:
      * F, a face,
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

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

The underlying polynomial ring of F.

+-------------------------+
|i1 : R=QQ[x_0..x_4];     |
+-------------------------+
|i2 : C=simplex R;        |
+-------------------------+
|i3 : F=C.fc_2_0          |
|                         |
|o3 = x x x               |
|      0 1 2              |
|                         |
|o3 : face with 3 vertices|
+-------------------------+
|i4 : simplexRing F       |
|                         |
|o4 = R                   |
|                         |
|o4 : PolynomialRing      |
+-------------------------+
|i5 : R.grading           |
|                         |
|o5 = | -1 -1 -1 -1 |     |
|     | 1  0  0  0  |     |
|     | 0  1  0  0  |     |
|     | 0  0  1  0  |     |
|     | 0  0  0  1  |     |
|                         |
|              5       4  |
|o5 : Matrix ZZ  <-- ZZ   |
+-------------------------+

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

  * simplexRing(Face) -- The underlying
    polynomial ring of a face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:5837:0.

simplexRing(FirstOrderDeformation) -- The underlying polynomial ring of a deformation or face.
**********************************************************************************************

  * Function: simplexRing,
  * Usage:
        simplexRing(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

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

Returns the underlying PolynomialRing (Macaulay2Doc), of
f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : simplexRing f                                    |
|                                                      |
|o6 = R                                                |
|                                                      |
|o6 : PolynomialRing                                   |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * simplexRing(FirstOrderDeformation)
    -- The underlying polynomial ring
    of a deformation or face.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4338:0.

source(FirstOrderDeformation) -- The source of a deformation.
*************************************************************

  * Function: source (Macaulay2Doc),
  * Usage:
        source(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a module (Macaulay2Doc),

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

Returns the source (Macaulay2Doc), of the homomorphisms
represented by f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                   |
|                                                      |
|o1 = R                                                |
|                                                      |
|o1 : PolynomialRing                                   |
+------------------------------------------------------+
|i2 : addCokerGrading(R)                               |
|                                                      |
|o2 = | -1 -1 -1 -1 |                                  |
|     | 1  0  0  0  |                                  |
|     | 0  1  0  0  |                                  |
|     | 0  0  1  0  |                                  |
|     | 0  0  0  1  |                                  |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : source f                                         |
|                                                      |
|o6 = image | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |     |
|                                                      |
|                             1                        |
|o6 : R-module, submodule of R                         |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * source(FirstOrderDeformation), --
    The source of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4426:0.

target(FirstOrderDeformation) -- The target of a deformation.
*************************************************************

  * Function: target (Macaulay2Doc),
  * Usage:
        target(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a module (Macaulay2Doc),

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

Returns the target (Macaulay2Doc), of the homomorphisms
represented by f.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : target f                                         |
|                                                      |
|o6 = cokernel | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |  |
|                                                      |
|                            1                         |
|o6 : R-module, quotient of R                          |
+------------------------------------------------------+

See also
========

  * FirstOrderDeformation -- The class of all
    first order deformations of monomial ideals.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

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

  * target(FirstOrderDeformation), --
    The target of a deformation.
-------------------------------------------------------------------------------

The source of this document is in SRdeformations.m2:4397:0.

toHom -- Convert a first order deformation into a homomorphism.
***************************************************************

  * Usage:
        toHom(f)
  * Inputs:
      * f, a first order deformation,
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Convert f into a homomorphism source(FirstOrderDeformation),
f -> See target(FirstOrderDeformation),
f. Requires
dim(FirstOrderDeformation), f to be 0 or 1.

+------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                  |
+------------------------------------------------------+
|i2 : addCokerGrading(R);                              |
|                                                      |
|              5       4                               |
|o2 : Matrix ZZ  <-- ZZ                                |
+------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0) |
|                                                      |
|o3 = ideal (x x , x x , x x , x x , x x )             |
|             0 1   1 2   2 3   3 4   0 4              |
|                                                      |
|o3 : Ideal of R                                       |
+------------------------------------------------------+
|i4 : mg=mingens I;                                    |
|                                                      |
|             1      5                                 |
|o4 : Matrix R  <-- R                                  |
+------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})|
|                                                      |
|       2                                              |
|      x                                               |
|       3                                              |
|o5 = ----                                             |
|     x x                                              |
|      0 1                                             |
|                                                      |
|o5 : first order deformation space of dimension 1     |
+------------------------------------------------------+
|i6 : fhom=toHom f                                     |
|                                                      |
|o6 = | 0 0 0 0 x_3^2 |                                |
|                                                      |
|o6 : Matrix                                           |
+------------------------------------------------------+
|i7 : source fhom                                      |
|                                                      |
|o7 = image | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |     |
|                                                      |
|                             1                        |
|o7 : R-module, submodule of R                         |
+------------------------------------------------------+
|i8 : target fhom                                      |
|                                                      |
|o8 = cokernel | x_3x_4 x_0x_4 x_2x_3 x_1x_2 x_0x_1 |  |
|                                                      |
|                            1                         |
|o8 : R-module, quotient of R                          |
+------------------------------------------------------+

See also
========

  * source(FirstOrderDeformation), --
    The source of a deformation.
  * target(FirstOrderDeformation), --
    The target of a deformation.
  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use toHom:
==================

  * "toHom(FirstOrderDeformation)"

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

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

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

The source of this document is in SRdeformations.m2:4922:0.

totalSpace -- Total space of a deformation.
*******************************************

  * Usage:
        totalSpace(f,R)
        totalSpace(L,R)
  * Inputs:
      * f, a first order deformation,
      * L, a list (Macaulay2Doc), of FirstOrderDeformation,
        s.
      * T, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an ideal (Macaulay2Doc),

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

Compute the total space of a first order deformation f or a list of first order
deformations. The polynomial ring T is used for the base. The number of
variables of T should match dim(FirstOrderDeformation),
f (respectively the sum over the deformations
in L).

+----------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                      |
+----------------------------------------------------------+
|i2 : addCokerGrading(R);                                  |
|                                                          |
|              5       4                                   |
|o2 : Matrix ZZ  <-- ZZ                                    |
+----------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)     |
|                                                          |
|o3 = ideal (x x , x x , x x , x x , x x )                 |
|             0 1   1 2   2 3   3 4   0 4                  |
|                                                          |
|o3 : Ideal of R                                           |
+----------------------------------------------------------+
|i4 : mg=mingens I;                                        |
|                                                          |
|             1      5                                     |
|o4 : Matrix R  <-- R                                      |
+----------------------------------------------------------+
|i5 : f=firstOrderDeformation(mg, vector {-1,-1,0,2,0})    |
|                                                          |
|       2                                                  |
|      x                                                   |
|       3                                                  |
|o5 = ----                                                 |
|     x x                                                  |
|      0 1                                                 |
|                                                          |
|o5 : first order deformation space of dimension 1         |
+----------------------------------------------------------+
|i6 : S=QQ[t]                                              |
|                                                          |
|o6 = S                                                    |
|                                                          |
|o6 : PolynomialRing                                       |
+----------------------------------------------------------+
|i7 : totalSpace(f,S)                                      |
|                                                          |
|                                       2                  |
|o7 = ideal (x x , x x , x x , x x , t*x  + x x )          |
|             3 4   0 4   2 3   1 2     3    0 1           |
|                                                          |
|o7 : Ideal of QQ[t, x ..x ]                               |
|                     0   4                                |
+----------------------------------------------------------+
|i8 : f1=firstOrderDeformation(mg, vector {0,-1,-1,0,2})   |
|                                                          |
|       2                                                  |
|      x                                                   |
|       4                                                  |
|o8 = ----                                                 |
|     x x                                                  |
|      1 2                                                 |
|                                                          |
|o8 : first order deformation space of dimension 1         |
+----------------------------------------------------------+
|i9 : S=QQ[t1,t2]                                          |
|                                                          |
|o9 = S                                                    |
|                                                          |
|o9 : PolynomialRing                                       |
+----------------------------------------------------------+
|i10 : totalSpace({f,f1},S)                                |
|                                                          |
|                                   2             2        |
|o10 = ideal (x x , x x , x x , t2*x  + x x , t1*x  + x x )|
|              3 4   0 4   2 3      4    1 2      3    0 1 |
|                                                          |
|o10 : Ideal of QQ[t1, t2, x ..x ]                         |
|                           0   4                          |
+----------------------------------------------------------+

See also
========

  * firstOrderDeformation -- Makes a first order
    deformation.
  * addCokerGrading -- Stores a cokernel grading in a
    polynomial ring.

Ways to use totalSpace:
=======================

  * "totalSpace(FirstOrderDeformation,PolynomialRing)"
  * "totalSpace(List,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:4886:0.

trivialDeformations -- Compute the trivial deformations.
********************************************************

  * Usage:
        trivialDeformations(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * a list (Macaulay2Doc), of FirstOrderDeformation,

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

Compute the deformations induced by root automorphisms of the embedding space
(i.e., excluding those coming from the torus).

+-----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4];                                                         |
+-----------------------------------------------------------------------------+
|i2 : addCokerGrading(R)                                                      |
|                                                                             |
|o2 = | -1 -1 -1 -1 |                                                         |
|     | 1  0  0  0  |                                                         |
|     | 0  1  0  0  |                                                         |
|     | 0  0  1  0  |                                                         |
|     | 0  0  0  1  |                                                         |
|                                                                             |
|              5       4                                                      |
|o2 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i3 : I=ideal(x_0*x_1,x_1*x_2,x_2*x_3,x_3*x_4,x_4*x_0)                        |
|                                                                             |
|o3 = ideal (x x , x x , x x , x x , x x )                                    |
|             0 1   1 2   2 3   3 4   0 4                                     |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : C=idealToComplex I                                                      |
|                                                                             |
|o4 = 1: x x  x x  x x  x x  x x                                              |
|         0 2  0 3  1 3  1 4  2 4                                             |
|                                                                             |
|o4 : complex of dim 1 embedded in dim 4 (printing facets)                    |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0}, Euler = -1    |
+-----------------------------------------------------------------------------+
|i5 : T=trivialDeformations C                                                 |
|                                                                             |
|      x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x  |
|       1   2   3   4   0   2   3   4   0   1   3   4   0   1   2   4   0   1 |
|o5 = {--, --, --, --, --, --, --, --, --, --, --, --, --, --, --, --, --, --,|
|      x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x   x  |
|       0   0   0   0   1   1   1   1   2   2   2   2   3   3   3   3   4   4 |
|     ------------------------------------------------------------------------|
|     x   x                                                                   |
|      2   3                                                                  |
|     --, --}                                                                 |
|     x   x                                                                   |
|      4   4                                                                  |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : tally apply(T,isTrivial)                                                |
|                                                                             |
|o6 = Tally{true => 20}                                                       |
|                                                                             |
|o6 : Tally                                                                   |
+-----------------------------------------------------------------------------+

Ways to use trivialDeformations:
================================

  * "trivialDeformations(Complex)"
  * "trivialDeformations(Ideal,Matrix)"
  * "trivialDeformations(Matrix)"

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

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

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

The source of this document is in SRdeformations.m2:5085:0.

tropDef -- The co-complex of tropical faces of the deformation polytope.
************************************************************************

  * Usage:
        tropDef(P,C)
  * Inputs:
      * C, an embedded complex, a simplicial complex
      * P, an embedded complex, the deformation polytope of C
        as returned by PT1, C.
  * Outputs:
      * an embedded co-complex,

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

Computes the co-complex of tropical faces of the deformation polytope.

This is work in progress.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_3]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : I=ideal(x_0*x_1,x_2*x_3)                                             |
|                                                                          |
|o2 = ideal (x x , x x )                                                   |
|             0 1   2 3                                                    |
|                                                                          |
|o2 : Ideal of R                                                           |
+--------------------------------------------------------------------------+
|i3 : C=idealToComplex I                                                   |
|                                                                          |
|o3 = 1: x x  x x  x x  x x                                                |
|         0 2  1 2  0 3  1 3                                               |
|                                                                          |
|o3 : complex of dim 1 embedded in dim 3 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 4, 4, 0, 0}, Euler = -1    |
+--------------------------------------------------------------------------+
|i4 : PT1C=PT1 C                                                           |
|                                                                          |
|o4 = 3: y y y y y y y y                                                   |
|         0 1 2 3 4 5 6 7                                                  |
|                                                                          |
|o4 : complex of dim 3 embedded in dim 3 (printing facets)                 |
|     equidimensional, non-simplicial, F-vector {1, 8, 14, 8, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i5 : tropDefC=tropDef(C,PT1C)                                             |
|                                                                          |
|o5 = 1: y y  y y  y y  y y                                                |
|         0 3  6 7  2 5  1 4                                               |
|                                                                          |
|o5 : co-complex of dim 1 embedded in dim 3 (printing facets)              |
|     equidimensional, non-simplicial, F-vector {0, 0, 4, 4, 1}, Euler = -1|
+--------------------------------------------------------------------------+
|i6 : tropDefC.grading                                                     |
|                                                                          |
|o6 = | -1 0  0  |                                                         |
|     | 1  0  0  |                                                         |
|     | -1 2  0  |                                                         |
|     | 0  -1 -1 |                                                         |
|     | 2  -1 -1 |                                                         |
|     | 0  1  -1 |                                                         |
|     | 0  -1 1  |                                                         |
|     | -1 0  2  |                                                         |
|                                                                          |
|              8       3                                                   |
|o6 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+

Caveat
======

The implementation of testing whether a face is tropical so far uses a trick to
emulate higher order. For complicated (non-complete intersections and
non-Pfaffians) examples this may lead to an incorrect result. Use with care.
This will be fixed at some point.

If using Polyhedra, to compute convex hulls and its faces
instead of ConvexInterface you are limited to rather simple examples.

See also
========

  * PT1 -- Compute the deformation polytope associated to a
    Stanley-Reisner complex.
  * saveDeformations -- Store the deformation data of
    a complex in a file.
  * convHull(String) -- The convex hull complex.
  * deform -- Compute the deformations associated to a
    Stanley-Reisner complex.

Ways to use tropDef:
====================

  * "tropDef(Complex,Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7689:0.

variables -- The variables of a complex or co-complex.
******************************************************

  * Usage:
        variables(C)
  * Inputs:
      * C, an embedded complex,
  * Outputs:
      * an embedded complex,

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

The variables of a complex of co-complex. Compare with vert.

+----------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_5]                                                         |
|                                                                            |
|o1 = R                                                                      |
|                                                                            |
|o1 : PolynomialRing                                                         |
+----------------------------------------------------------------------------+
|i2 : C=boundaryCyclicPolytope(3,R)                                          |
|                                                                            |
|o2 = 2: x x x  x x x  x x x  x x x  x x x  x x x  x x x  x x x              |
|         0 1 2  0 2 3  0 3 4  0 1 5  1 2 5  2 3 5  0 4 5  3 4 5             |
|                                                                            |
|o2 : complex of dim 2 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 6, 12, 8, 0, 0, 0}, Euler = 1|
+----------------------------------------------------------------------------+
|i3 : F=C.fc_0_0                                                             |
|                                                                            |
|o3 = x                                                                      |
|      0                                                                     |
|                                                                            |
|o3 : face with 1 vertex                                                     |
+----------------------------------------------------------------------------+
|i4 : lkF=link(F,C)                                                          |
|                                                                            |
|o4 = 1: x x  x x  x x  x x  x x                                             |
|         1 2  2 3  3 4  1 5  4 5                                            |
|                                                                            |
|o4 : complex of dim 1 embedded in dim 5 (printing facets)                   |
|     equidimensional, simplicial, F-vector {1, 5, 5, 0, 0, 0, 0}, Euler = -1|
+----------------------------------------------------------------------------+
|i5 : variables lkF                                                          |
|                                                                            |
|o5 = {x , x , x , x , x , x }                                               |
|       0   1   2   3   4   5                                                |
|                                                                            |
|o5 : List                                                                   |
+----------------------------------------------------------------------------+
|i6 : vert lkF                                                               |
|                                                                            |
|o6 = {x , x , x , x , x }                                                   |
|       5   4   3   2   1                                                    |
|                                                                            |
|o6 : List                                                                   |
+----------------------------------------------------------------------------+

See also
========

  * vert -- The vertices of a face or complex.

Ways to use variables:
======================

  * "variables(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:7012:0.

vectorToMonomial -- Converts an exponent vector into a monomial.
****************************************************************

  * Usage:
        vectorToMonomial(v,R)
  * Inputs:
      * v, a vector (Macaulay2Doc),
      * R, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc),

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

Converts the exponent vector v into a monomial in the variables of R. The
number of variables of R has to match the length of v.

+--------------------------+
|i1 : R=QQ[x_0..x_4]       |
|                          |
|o1 = R                    |
|                          |
|o1 : PolynomialRing       |
+--------------------------+
|i2 : m=vector {1,2,1,0,0} |
|                          |
|o2 = | 1 |                |
|     | 2 |                |
|     | 1 |                |
|     | 0 |                |
|     | 0 |                |
|                          |
|       5                  |
|o2 : ZZ                   |
+--------------------------+
|i3 : vectorToMonomial(m,R)|
|                          |
|        2                 |
|o3 = x x x                |
|      0 1 2               |
|                          |
|o3 : R                    |
+--------------------------+

See also
========

  * laurent -- Converts an exponent vector or a deformation
    into a Laurent monomial.

Ways to use vectorToMonomial:
=============================

  * "vectorToMonomial(Vector,PolynomialRing)"

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

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

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

The source of this document is in SRdeformations.m2:4092:0.

vert -- The vertices of a face or complex.
******************************************

  * Usage:
        vert(F)
        vert(C)
  * Inputs:
      * F, a face,
      * C, an embedded complex,
  * Outputs:
      * a list (Macaulay2Doc),

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

The vertices of F or C.

+-------------------------+
|i1 : R=QQ[x_0..x_4];     |
+-------------------------+
|i2 : addCokerGrading R;  |
|                         |
|              5       4  |
|o2 : Matrix ZZ  <-- ZZ   |
+-------------------------+
|i3 : C=simplex R;        |
+-------------------------+
|i4 : vert C              |
|                         |
|o4 = {x , x , x , x , x }|
|       4   3   2   1   0 |
|                         |
|o4 : List                |
+-------------------------+
|i5 : F=C.fc_2_0          |
|                         |
|o5 = x x x               |
|      0 1 2              |
|                         |
|o5 : face with 3 vertices|
+-------------------------+
|i6 : vert F              |
|                         |
|o6 = {x , x , x }        |
|       0   1   2         |
|                         |
|o6 : List                |
+-------------------------+

See also
========

  * coordinates -- The coordinates of a face.

Ways to use vert:
=================

  * "vert(Complex)"
  * "vert(Face)"

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

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

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

The source of this document is in SRdeformations.m2:5813:0.

verticesDualPolytope -- The dual vertices of a polytope.
********************************************************

  * Usage:
        verticesDualPolytope(C)
  * Inputs:
      * C, an embedded complex, a polytope
  * Outputs:
      * a matrix (Macaulay2Doc),

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

Computes the vertices of the dual polytope of C in the row of a matrix. The
rows are sorted according to the polytopalFacets, of C.

+--------------------------------------------------------------------------+
|i1 : R=QQ[x_0..x_4]                                                       |
|                                                                          |
|o1 = R                                                                    |
|                                                                          |
|o1 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i2 : C=simplex(R)                                                         |
|                                                                          |
|o2 = 4: x x x x x                                                         |
|         0 1 2 3 4                                                        |
|                                                                          |
|o2 : complex of dim 4 embedded in dim 4 (printing facets)                 |
|     equidimensional, simplicial, F-vector {1, 5, 10, 10, 5, 1}, Euler = 0|
+--------------------------------------------------------------------------+
|i3 : verticesDualPolytope C                                               |
|                                                                          |
|o3 = | -1 -1 -1 4  |                                                      |
|     | -1 -1 4  -1 |                                                      |
|     | -1 4  -1 -1 |                                                      |
|     | 4  -1 -1 -1 |                                                      |
|     | -1 -1 -1 -1 |                                                      |
|                                                                          |
|              5       4                                                   |
|o3 : Matrix QQ  <-- QQ                                                    |
+--------------------------------------------------------------------------+

See also
========

  * dualGrading -- The dual vertices of a polytope.
  * grading -- The grading of a first order deformation or
    complex or polynomial ring.
  * polytopalFacets -- The facets of a polytope.
  * dualize -- The dual of a face or complex.
  * isPolytope -- Check whether a complex is a polytope.
  * facets -- The maximal faces of a complex.

Ways to use verticesDualPolytope:
=================================

  * "verticesDualPolytope(Complex)"

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

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

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

The source of this document is in SRdeformations.m2:6060:0.