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

SimplicialDecomposability -- various decomposability routines for simplicial complexes.
***************************************************************************************

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

This package includes routines for vertex decomposability and shellability for
arbitrary simplicial complexes as well as routines for k-decomposability.
Moreover, it can find a shelling order for a shellable simplicial complex.

References:

[BW-1] A. Bjoerner and M. Wachs, "Shellable nonpure complexes and posets, I,"
Trans. of the AMS 348 (1996), 1299–1327.

[BW-2] A. Bjoerner and M. Wachs, "Shellable nonpure complexes and posets, II,"
Trans. of the AMS 349 (1997), 3945–3975.

[MT] S. Moriyama and F. Takeuchi, "Incremental construction properties in
dimension two: shellability, extendable shellability and vertex
decomposability," Discrete Math. 263 (2003), 295–296.

[PB] J. S. Provan and L. J. Billera, "Decompositions of Simplicial Complexes
Related to Diameters of Convex Polyhedra," Math. of Operations Research 5
(1980), 576–594.

[St] R. Stanley, "Combinatorics and Commutative Algebra," 2nd edition.
Progress in Mathematics, 41. Birkhaeuser Boston, Inc. Boston, MA, 1996.

[Wo] R. Woodroofe, "Chordal and sequentially Cohen-Macaulay clutters,"
arXiv:0911.4697v1.

Author
======

  * David Cook II (see http://ux1.eiu.edu/~dwcook/ ) <dwcook@eiu.edu>

Certification a gold star
=========================

Version 1.0.5 of this package was accepted for publication in volume 2 (see
https://msp.org/jsag/2010/2-1/ ) of The Journal of Software for Algebra and
Geometry: Macaulay2 (see https://msp.org/jsag/ ) on 2010-08-03, in the article
Simplicial Decomposability (see https://msp.org/jsag/2010/2-1/p05.xhtml ) (DOI:
10.2140/jsag.2010.2.20 (see https://doi.org/10.2140/jsag.2010.2.20 )). That
version can be obtained from the journal (see
https://msp.org/jsag/2010/2-1/jsag-v2-n1-x05-code.zip ).

Version
=======

This documentation describes version 1.0.6 of SimplicialDecomposability.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{SimplicialDecomposabilitySource,                                       |
|  title = {{SimplicialDecomposability: various decomposability routines for  |
|  author = {David Cook II},                                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{SimplicialDecomposabilityArticle,                                   |
|  title = {{Simplicial Decomposability}},                                    |
|  author = {David Cook II},                                                  |
|  journal = {The Journal of Software for Algebra and Geometry: Macaulay2},   |
|  volume = {2},                                                              |
|  year = {2010},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|simplicial complexes. Version~1.0.6}},                                       |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * allFaces -- returns all faces of a simplicial complex,
        up to a given dimension
      * faceDelete -- computes the face deletion for a
        simplicial complex
      * fTriangle -- determines the f-Triangle of a
        simplicial complex
      * hTriangle -- determines the h-Triangle of a
        simplicial complex
      * hVector -- the h-vector of a simplicial complex
      * isDecomposable -- determines whether a
        simplicial complex is k-decomposable
      * isSheddingFace -- determines whether a face of a
        simplicial complex is a shedding face
      * isSheddingVertex -- determines whether a
        vertex of a simplicial complex is a shedding vertex
      * isShellable -- determines whether a simplicial
        complex is shellable
      * isShelling -- determines whether a list of faces is
        a shelling
      * isSimplex -- determines whether a simplicial complex
        is simplex
      * isVertexDecomposable -- determines whether
        a simplicial complex is vertex-decomposable
      * shellingOrder -- finds a shelling of a simplicial
        complex, if one exists
  * Methods
      * "allFaces(SimplicialComplex)" -- see allFaces, --
        returns all faces of a simplicial complex, up to a given dimension
      * "allFaces(ZZ,SimplicialComplex)" -- see allFaces, --
        returns all faces of a simplicial complex, up to a given dimension
      * "faceDelete(RingElement,SimplicialComplex)" -- see faceDelete,
        -- computes the face deletion for a simplicial complex
      * "fTriangle(SimplicialComplex)" -- see fTriangle, --
        determines the f-Triangle of a simplicial complex
      * "hTriangle(SimplicialComplex)" -- see hTriangle, --
        determines the h-Triangle of a simplicial complex
      * "hVector(SimplicialComplex)" -- see hVector, -- the
        h-vector of a simplicial complex
      * "isDecomposable(ZZ,SimplicialComplex)" -- see isDecomposable,
        -- determines whether a simplicial complex is
        k-decomposable
      * "isSheddingFace(RingElement,SimplicialComplex)" -- see
        isSheddingFace, -- determines whether a face of a
        simplicial complex is a shedding face
      * "isSheddingVertex(RingElement,SimplicialComplex)" -- see
        isSheddingVertex, -- determines whether a vertex of a
        simplicial complex is a shedding vertex
      * "isShellable(SimplicialComplex)" -- see isShellable,
        -- determines whether a simplicial complex is shellable
      * "isShelling(List)" -- see isShelling, -- determines
        whether a list of faces is a shelling
      * "isSimplex(SimplicialComplex)" -- see isSimplex, --
        determines whether a simplicial complex is simplex
      * "isVertexDecomposable(SimplicialComplex)" -- see
        isVertexDecomposable, -- determines whether a
        simplicial complex is vertex-decomposable
      * "shellingOrder(SimplicialComplex)" -- see shellingOrder,
        -- finds a shelling of a simplicial complex, if one
        exists
  * Symbols

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

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

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

The source of this document is in SimplicialDecomposability.m2:471:0.

allFaces -- returns all faces of a simplicial complex, up to a given dimension
******************************************************************************

  * Usage:
        allFaces S
        allFaces(k, S)
  * Inputs:
      * k, an integer (Macaulay2Doc), the highest dimension to return
        ($dim S$ by default)
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * L, a list (Macaulay2Doc), the list of all faces of $S$
        (excluding the $(-1)$-dimensional face \{\}) up to dimension $k$

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

+-----------------------------------------------------------------------------+
|i1 : R = QQ[a..e];                                                           |
+-----------------------------------------------------------------------------+
|i2 : S = simplicialComplex {a*b*c*d*e};                                      |
+-----------------------------------------------------------------------------+
|i3 : allFaces S                                                              |
|                                                                             |
|o3 = {a, b, c, d, e, a*b, a*c, a*d, a*e, b*c, b*d, b*e, c*d, c*e, d*e, a*b*c,|
|     ------------------------------------------------------------------------|
|     a*b*d, a*b*e, a*c*d, a*c*e, a*d*e, b*c*d, b*c*e, b*d*e, c*d*e, a*b*c*d, |
|     ------------------------------------------------------------------------|
|     a*b*c*e, a*b*d*e, a*c*d*e, b*c*d*e, a*b*c*d*e}                          |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : allFaces(2, S)                                                          |
|                                                                             |
|o4 = {a, b, c, d, e, a*b, a*c, a*d, a*e, b*c, b*d, b*e, c*d, c*e, d*e, a*b*c,|
|     ------------------------------------------------------------------------|
|     a*b*d, a*b*e, a*c*d, a*c*e, a*d*e, b*c*d, b*c*e, b*d*e, c*d*e}          |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * faces (Polyhedra) -- computes all faces of a certain
    codimension of a Cone or Polyhedron
  * facets (Polyhedra) -- Giving the facet inequalities of a cone
    or polyhedron.

Ways to use allFaces:
=====================

  * "allFaces(SimplicialComplex)"
  * "allFaces(ZZ,SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:500:0.

faceDelete -- computes the face deletion for a simplicial complex
*****************************************************************

  * Usage:
        faceDelete(F, S)
  * Inputs:
      * F, a ring element (Macaulay2Doc), a face of $S$
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * T, an abstract simplicial complex (SimplicialComplexes),
        the simplicial complex of all
        faces in $S$ not containing the face $F$

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

+------------------------------------------------+
|i1 : R = QQ[a..e];                              |
+------------------------------------------------+
|i2 : S = simplicialComplex {a*b*c*d*e};         |
+------------------------------------------------+
|i3 : faceDelete(a, S)                           |
|                                                |
|o3 = simplicialComplex | bcde |                 |
|                                                |
|o3 : SimplicialComplex                          |
+------------------------------------------------+
|i4 : faceDelete(a*b*c, S)                       |
|                                                |
|o4 = simplicialComplex | bcde acde abde |       |
|                                                |
|o4 : SimplicialComplex                          |
+------------------------------------------------+
|i5 : faceDelete(a*b*c*d*e, S) === skeleton(3, S)|
|                                                |
|o5 = true                                       |
+------------------------------------------------+

Caveat
======

Do not confuse face deletion with normal deletion wherein the vertices of the
given face are entirely removed.

See also
========

  * link (SimplicialComplexes),
    -- make the link of a face in an abstract simplicial complex

Ways to use faceDelete:
=======================

  * "faceDelete(RingElement,SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:530:0.

fTriangle -- determines the f-Triangle of a simplicial complex
**************************************************************

  * Usage:
        fTriangle S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * f, a tally (Macaulay2Doc), the f-Triangle of $S$

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

Definition 3.1 in [BW-1] defines the f-Triangle, a generalisation of the
f-Vector, to have entries $f#(i,j)$ equal to the number of faces of $S$ with
degree $i$ and dimension $j-1$. The degree of a face is the dimension of the
largest face of $S$ containing it, plus one.

If $S$ is pure, then the last row is the traditional f-Vector and the remainder
is zeros.

+-------------------------------------------------------------------+
|i1 : R = QQ[a..e];                                                 |
+-------------------------------------------------------------------+
|i2 : fTriangle simplicialComplex {a*b*c, c*d*e, a*d, a*e, b*d, b*e}|
|                                                                   |
|o2 = Tally{(2, 2) => 4}                                            |
|           (3, 0) => 1                                             |
|           (3, 1) => 5                                             |
|           (3, 2) => 6                                             |
|           (3, 3) => 2                                             |
|                                                                   |
|o2 : Tally                                                         |
+-------------------------------------------------------------------+
|i3 : fTriangle simplicialComplex {a*b*c*d*e}                       |
|                                                                   |
|o3 = Tally{(5, 0) => 1 }                                           |
|           (5, 1) => 5                                             |
|           (5, 2) => 10                                            |
|           (5, 3) => 10                                            |
|           (5, 4) => 5                                             |
|           (5, 5) => 1                                             |
|                                                                   |
|o3 : Tally                                                         |
+-------------------------------------------------------------------+

See also
========

  * fVector (Polyhedra) -- computes the f-vector of a Cone,
    Polyhedron, Fan or PolyhedralComplex
  * hTriangle -- determines the h-Triangle of a simplicial
    complex

Ways to use fTriangle:
======================

  * "fTriangle(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:562:0.

hTriangle -- determines the h-Triangle of a simplicial complex
**************************************************************

  * Usage:
        hTriangle S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * h, a tally (Macaulay2Doc), the h-Triangle of $S$

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

Definition 3.1 in [BW-1] defines the h-Triangle, a generalisation of the
h-Vector.

If $S$ is pure, then the last row is the traditional h-Vector and the remainder
is zeros.

+-------------------------------------------------------------------+
|i1 : R = QQ[a..e];                                                 |
+-------------------------------------------------------------------+
|i2 : hTriangle simplicialComplex {a*b*c, c*d*e, a*d, a*e, b*d, b*e}|
|                                                                   |
|o2 = Tally{(2, 2) => 4 }                                           |
|           (3, 0) => 1                                             |
|           (3, 1) => 2                                             |
|           (3, 2) => -1                                            |
|                                                                   |
|o2 : Tally                                                         |
+-------------------------------------------------------------------+
|i3 : hTriangle simplicialComplex {a*b*c*d*e}                       |
|                                                                   |
|o3 = Tally{(5, 0) => 1}                                            |
|                                                                   |
|o3 : Tally                                                         |
+-------------------------------------------------------------------+

See also
========

  * fTriangle -- determines the f-Triangle of a simplicial
    complex
  * hVector -- the h-vector of a simplicial complex

Ways to use hTriangle:
======================

  * "hTriangle(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:591:0.

hVector -- the h-vector of a simplicial complex
***********************************************

  * Usage:
        h = hVector D
  * Inputs:
      * D, an abstract simplicial complex (SimplicialComplexes),
  * Optional inputs (Macaulay2Doc),:
      * Flag => a Boolean value (Macaulay2Doc), default value
        false, the flag h-vector if the simplicial complex is properly defined
        over a multigraded ring.
  * Outputs:
      * h, such that h#i is the i-th entry of the h-vector of D for an integer
        0 <= i <= dim D+1 or a squarefree degree i.

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

The h-vector of the 4-simplex.
+------------------------------------------+
|i1 : R = ZZ[a..e];                        |
+------------------------------------------+
|i2 : smplex = simplicialComplex{a*b*c*d*e}|
|                                          |
|o2 = simplicialComplex | abcde |          |
|                                          |
|o2 : SimplicialComplex                    |
+------------------------------------------+
|i3 : hVector smplex                       |
|                                          |
|o3 = HashTable{0 => 1}                    |
|               1 => 0                     |
|               2 => 0                     |
|               3 => 0                     |
|               4 => 0                     |
|               5 => 0                     |
|                                          |
|o3 : HashTable                            |
+------------------------------------------+
A filled triangle with two edges attached to two vertices shows that the
h-vector can have negative entries.
+-----------------------------------------------------------+
|i4 : R = ZZ[x_1..x_5];                                     |
+-----------------------------------------------------------+
|i5 : delta = simplicialComplex{x_1*x_2*x_3,x_2*x_4,x_3*x_5}|
|                                                           |
|o5 = simplicialComplex | x_3x_5 x_2x_4 x_1x_2x_3 |         |
|                                                           |
|o5 : SimplicialComplex                                     |
+-----------------------------------------------------------+
|i6 : hVector delta                                         |
|                                                           |
|o6 = HashTable{0 => 1 }                                    |
|               1 => 2                                      |
|               2 => -2                                     |
|               3 => 0                                      |
|                                                           |
|o6 : HashTable                                             |
+-----------------------------------------------------------+
The last example above can be considered in a Z^3-graded ring. Then we can
compute its flag h-vector.
+---------------------------------------------------------+
|i7 : grading = {{1,0,0},{1,0,0},{1,0,0},{0,1,0},{0,0,1}};|
+---------------------------------------------------------+
|i8 : R = ZZ[x_1,x_2,x_3,y,z, Degrees => grading];        |
+---------------------------------------------------------+
|i9 : gamma = simplicialComplex{x_1*y*z,x_2*y,x_3*z}      |
|                                                         |
|o9 = simplicialComplex | x_3z x_2y x_1yz |               |
|                                                         |
|o9 : SimplicialComplex                                   |
+---------------------------------------------------------+
|i10 : hVector(gamma, Flag => true)                       |
|                                                         |
|o10 = HashTable{{0, 0, 0} => 1 }                         |
|                {1, 0, 0} => 2                           |
|                {1, 0, 1} => -1                          |
|                {1, 1, 0} => -1                          |
|                                                         |
|o10 : HashTable                                          |
+---------------------------------------------------------+

Caveat
======

The option Flag checks if the multigrading corresponds to a properly d-coloring
of D, where d is the dimension of D plus one. If it is not the case the output
is an empty HashTable.

See also
========

  * SimplicialComplexes -- exploring abstract
    simplicial complexes within commutative algebra
  * faces (Polyhedra) -- computes all faces of a certain
    codimension of a Cone or Polyhedron

Ways to use hVector:
====================

  * "hVector(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:940:0.

isDecomposable -- determines whether a simplicial complex is k-decomposable
***************************************************************************

  * Usage:
        isDecomposable(k, S)
  * Inputs:
      * k, an integer (Macaulay2Doc),
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $S$ is $k$-decomposable

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

Definition 3.6 of [Wo] states that a simplicial complex $S$ is $k$-decomposable
if $S$ is either a simplex or there exists a shedding face $F$ of $S$ of
dimension at most $k$ such that both the face deletion and link of $S$ by $F$
are again $k$-decomposable.

+---------------------------------------------------------------+
|i1 : R = QQ[a..f];                                             |
+---------------------------------------------------------------+
|i2 : isDecomposable(0, simplicialComplex {a*b*c*d*e*f})        |
|                                                               |
|o2 = true                                                      |
+---------------------------------------------------------------+
|i3 : isDecomposable(2, simplicialComplex {a*b*c, b*c*d, c*d*e})|
|                                                               |
|o3 = true                                                      |
+---------------------------------------------------------------+

The method checks the cache, if possible, to see if the complex is
vertex-decomposable.

See also
========

  * faceDelete -- computes the face deletion for a
    simplicial complex
  * isSheddingFace -- determines whether a face of a
    simplicial complex is a shedding face
  * isShellable -- determines whether a simplicial complex
    is shellable
  * isVertexDecomposable -- determines whether a
    simplicial complex is vertex-decomposable
  * link (SimplicialComplexes),
    -- make the link of a face in an abstract simplicial complex

Ways to use isDecomposable:
===========================

  * "isDecomposable(ZZ,SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:628:0.

isSheddingFace -- determines whether a face of a simplicial complex is a shedding face
**************************************************************************************

  * Usage:
        isSheddingFace(F, S)
  * Inputs:
      * F, a ring element (Macaulay2Doc), a face of $S$
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $F$ is a shedding face of $S$

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

Definition 3.1 in [Wo] states that a face $F$ of a simplicial complex $S$ is a
shedding face if every face $G$ of the star of $S$ by $F$ satisfies the
exchange property, that is, for every vertex $v$ of $F$ there is a vertex $w$
of the face deletion of $S$ by $G$ such that $(G \cup w) \setminus v$ is a face
of $S$.

+-------------------------------------------------+
|i1 : R = QQ[a..e];                               |
+-------------------------------------------------+
|i2 : T = simplicialComplex {a*b*c, b*c*d, c*d*e};|
+-------------------------------------------------+
|i3 : isSheddingFace(b*d, T)                      |
|                                                 |
|o3 = true                                        |
+-------------------------------------------------+
|i4 : isSheddingFace(b*c*d, T)                    |
|                                                 |
|o4 = false                                       |
+-------------------------------------------------+

See also
========

  * faceDelete -- computes the face deletion for a
    simplicial complex
  * isDecomposable -- determines whether a simplicial
    complex is k-decomposable
  * isShellable -- determines whether a simplicial complex
    is shellable
  * isVertexDecomposable -- determines whether a
    simplicial complex is vertex-decomposable
  * link (SimplicialComplexes),
    -- make the link of a face in an abstract simplicial complex

Ways to use isSheddingFace:
===========================

  * "isSheddingFace(RingElement,SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:664:0.

isSheddingVertex -- determines whether a vertex of a simplicial complex is a shedding vertex
********************************************************************************************

  * Usage:
        isSheddingVertex(x, S)
  * Inputs:
      * x, a ring element (Macaulay2Doc), a vertex of $S$
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $x$ is a shedding vertex of $S$

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

Definition 11.1 of [BW-2] states that a shedding vertex $x$ of a simplicial
complex $S$ is a vertex such that the link and face deletion of $x$ from $S$
are vertex decomposable and share no common facets.

+-------------------------------------------------------+
|i1 : R = QQ[a..f];                                     |
+-------------------------------------------------------+
|i2 : S = simplicialComplex {a*b*c, c*d, d*e, e*f, d*f};|
+-------------------------------------------------------+
|i3 : isSheddingVertex(a, S)                            |
|                                                       |
|o3 = false                                             |
+-------------------------------------------------------+
|i4 : isSheddingVertex(f, S)                            |
|                                                       |
|o4 = true                                              |
+-------------------------------------------------------+

See also
========

  * faceDelete -- computes the face deletion for a
    simplicial complex
  * isVertexDecomposable -- determines whether a
    simplicial complex is vertex-decomposable
  * link (SimplicialComplexes),
    -- make the link of a face in an abstract simplicial complex

Ways to use isSheddingVertex:
=============================

  * "isSheddingVertex(RingElement,SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:696:0.

isShellable -- determines whether a simplicial complex is shellable
*******************************************************************

  * Usage:
        isShellable S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $S$ is shellable

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

The pure and non-pure cases are handled separately.  If $S$ is pure, then
definition III.2.1 in [St] is used.  That is, $S$ is shellable if its facets
can be ordered $F_1, ..., F_n$ so that the difference in the $j$-th and
$j-1$-th subcomplex has a unique minimal face, for $2 \leq j \leq n$.

If $S$ is non-pure, then definition 2.1 in [BW-1] is used.  That is, a
simplicial complex $S$ is shellable if the facets of $S$ can be ordered $F_1,
.., F_n$ such that the intersection of the faces of the first $j-1$ with the
faces of the $F_j$ is pure and $dim F_j - 1$-dimensional.

+--------------------------------------------------------------+
|i1 : R = QQ[a..f];                                            |
+--------------------------------------------------------------+
|i2 : isShellable simplicialComplex {a*b*c*d*e}                |
|                                                              |
|o2 = true                                                     |
+--------------------------------------------------------------+
|i3 : isShellable simplicialComplex {a*b*c, c*d*e}             |
|                                                              |
|o3 = false                                                    |
+--------------------------------------------------------------+
|i4 : isShellable simplicialComplex {a*b*c, b*c*d, c*d*e}      |
|                                                              |
|o4 = true                                                     |
+--------------------------------------------------------------+
|i5 : isShellable simplicialComplex {a*b*c, c*d, d*e, e*f, d*f}|
|                                                              |
|o5 = true                                                     |
+--------------------------------------------------------------+
|i6 : isShellable simplicialComplex {a*b*c, c*d, d*e*f}        |
|                                                              |
|o6 = false                                                    |
+--------------------------------------------------------------+

See also
========

  * facets (Polyhedra) -- Giving the facet inequalities of a cone
    or polyhedron.
  * isDecomposable -- determines whether a simplicial
    complex is k-decomposable
  * isShelling -- determines whether a list of faces is a
    shelling
  * shellingOrder -- finds a shelling of a simplicial
    complex, if one exists

Ways to use isShellable:
========================

  * "isShellable(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:736:0.

isShelling -- determines whether a list of faces is a shelling
**************************************************************

  * Usage:
        isShelling L
  * Inputs:
      * L, a list (Macaulay2Doc), a list of faces (i.e., squarefree
        monic monomials)
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $L$ is shelling

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

Determines if a list of faces is a shelling order of the simplicial complex
generated by the list.

Let $S$ be the simplicial complex generated by the list of facets $L$.  If $S$
is pure, then definition III.2.1 in [St] is used. That is, $L_1, .., L_n$ is a
shelling order of $S$ if the difference in the $j$-th and $j-1$-th subcomplex
has a unique minimal face, for $2 \leq j \leq n$.

If $S$ is non-pure, then definition 2.1 in [BW-1] is used.  That is, $L_1, ..,
L_n$ is a shelling order if the intersection of the faces of the first $j-1$
facets with the faces of the $L_j$ is pure and $dim L_j - 1$-dimensional.

+-------------------------------------+
|i1 : R = QQ[a..e];                   |
+-------------------------------------+
|i2 : isShelling {a*b*c, b*c*d, c*d*e}|
|                                     |
|o2 = true                            |
+-------------------------------------+
|i3 : isShelling {a*b*c, c*d*e, b*c*d}|
|                                     |
|o3 = false                           |
+-------------------------------------+

See also
========

  * isShellable -- determines whether a simplicial complex
    is shellable
  * shellingOrder -- finds a shelling of a simplicial
    complex, if one exists

Ways to use isShelling:
=======================

  * "isShelling(List)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:774:0.

isSimplex -- determines whether a simplicial complex is simplex
***************************************************************

  * Usage:
        isSimplex S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $S$ is simplex

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

+-------------------------------------------+
|i1 : R = QQ[a..d];                         |
+-------------------------------------------+
|i2 : isSimplex simplicialComplex {a*b*c*d} |
|                                           |
|o2 = true                                  |
+-------------------------------------------+
|i3 : isSimplex simplicialComplex {a*b}     |
|                                           |
|o3 = true                                  |
+-------------------------------------------+
|i4 : isSimplex simplicialComplex {a*b, c*d}|
|                                           |
|o4 = false                                 |
+-------------------------------------------+

See also
========

  * facets (Polyhedra) -- Giving the facet inequalities of a cone
    or polyhedron.

Ways to use isSimplex:
======================

  * "isSimplex(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:797:0.

isVertexDecomposable -- determines whether a simplicial complex is vertex-decomposable
**************************************************************************************

  * Usage:
        isVertexDecomposable S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), true if and only if
        $S$ is vertex-decomposable

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

Vertex-decomposability is just zero-decomposability when $S$ is pure, see [PB].
When $S$ is non-pure, [BW-2] gives a generalisation: A complex $S$ is vertex
decomposable if it is either a simplex or there exists a shedding vertex.

+-----------------------------------------------------------------------+
|i1 : R = QQ[a..f];                                                     |
+-----------------------------------------------------------------------+
|i2 : isVertexDecomposable simplicialComplex {a*b*c*d*e}                |
|                                                                       |
|o2 = true                                                              |
+-----------------------------------------------------------------------+
|i3 : isVertexDecomposable skeleton(3, simplicialComplex {a*b*c*d*e})   |
|                                                                       |
|o3 = true                                                              |
+-----------------------------------------------------------------------+
|i4 : isVertexDecomposable simplicialComplex {a*b*c, c*d*e}             |
|                                                                       |
|o4 = false                                                             |
+-----------------------------------------------------------------------+
|i5 : isVertexDecomposable simplicialComplex {a*b*c, c*d, d*e, e*f, d*f}|
|                                                                       |
|o5 = true                                                              |
+-----------------------------------------------------------------------+

Whether the complex is vertex-decomposable is cached.

See also
========

  * isDecomposable -- determines whether a simplicial
    complex is k-decomposable
  * isSheddingVertex -- determines whether a vertex of
    a simplicial complex is a shedding vertex

Ways to use isVertexDecomposable:
=================================

  * "isVertexDecomposable(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:829:0.

shellingOrder -- finds a shelling of a simplicial complex, if one exists
************************************************************************

  * Usage:
        L = shellingOrder S
  * Inputs:
      * S, an abstract simplicial complex (SimplicialComplexes),
  * Optional inputs (Macaulay2Doc),:
      * Permutation => a list (Macaulay2Doc), default value {}, of
        integers from $0$ to one less than the number of facets which is
        applied to the facets before the recursive search for a shelling is
        executed.
      * Random => a Boolean value (Macaulay2Doc), default value
        false, whether to use a random permutation to the facet list before the
        recursive search for a shelling is executed.
  * Outputs:
      * L, a list (Macaulay2Doc), a shelling order of the facets of
        $S$, if one exists

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

If $S$ is pure, then definition III.2.1 in [St] is used.  That is, $S$ is
shellable if its facets can be ordered $F_1, .., F_n$ so that the difference in
the $j$-th and $j-1$-th subcomplex has a unique minimal face, for $2 \leq j
\leq n$.

If $S$ is non-pure, then definition 2.1 in [BW-1] is used.  That is, a
simplicial complex $S$ is shellable if the facets of $S$ can be ordered $F_1,
.., F_n$ such that the intersection of the faces of the first $j-1$ with the
faces of the $F_j$ is pure and $dim F_j - 1$-dimensional.

This function attempts to build up a shelling order of $S$ recursively.  In
particular, a depth-first search is used to attempt to build up a shelling
order from the bottom, that is, from the first facet in the order.

In the case when $S$ is non-pure, then the search is restricted to the maximal
dimension facets remaining to be added.  This allows a shelling order in
reverse dimension order to be returned whenever $S$ is indeed shellable.

+----------------------------------------------------------------+
|i1 : R = QQ[a..f];                                              |
+----------------------------------------------------------------+
|i2 : shellingOrder simplicialComplex {a*b*c*d*e}                |
|                                                                |
|o2 = {a*b*c*d*e}                                                |
|                                                                |
|o2 : List                                                       |
+----------------------------------------------------------------+
|i3 : shellingOrder simplicialComplex {a*b*c, b*c*d, c*d*e}      |
|                                                                |
|o3 = {c*d*e, b*c*d, a*b*c}                                      |
|                                                                |
|o3 : List                                                       |
+----------------------------------------------------------------+
|i4 : shellingOrder simplicialComplex {a*b*c, c*d*e}             |
|                                                                |
|o4 = {}                                                         |
|                                                                |
|o4 : List                                                       |
+----------------------------------------------------------------+
|i5 : shellingOrder simplicialComplex {a*b*c, c*d, d*e, e*f, d*f}|
|                                                                |
|o5 = {a*b*c, c*d, d*e, d*f, e*f}                                |
|                                                                |
|o5 : List                                                       |
+----------------------------------------------------------------+
|i6 : shellingOrder simplicialComplex {a*b*c, c*d, d*e*f}        |
|                                                                |
|o6 = {}                                                         |
|                                                                |
|o6 : List                                                       |
+----------------------------------------------------------------+

The options Random and Permutation can be used to try to find alternate
shelling orders.  Random applies a random permutation to the facet list and
Permutation applies a supplied permutation to the list.  In the non-pure case,
the facets are subsequently ordered in reverse dimension order but retaining
the ordering within dimensions.

The options Random and Permutation are mutually exclusive.

+--------------------------------------------------------+
|i7 : S = simplicialComplex {a*b*c, b*c*d, c*d*e, d*e*f};|
+--------------------------------------------------------+
|i8 : shellingOrder S                                    |
|                                                        |
|o8 = {d*e*f, c*d*e, b*c*d, a*b*c}                       |
|                                                        |
|o8 : List                                               |
+--------------------------------------------------------+
|i9 : shellingOrder(S, Random => true)                   |
|                                                        |
|o9 = {b*c*d, a*b*c, c*d*e, d*e*f}                       |
|                                                        |
|o9 : List                                               |
+--------------------------------------------------------+
|i10 : shellingOrder(S, Permutation => {3,2,1,0})        |
|                                                        |
|o10 = {a*b*c, b*c*d, c*d*e, d*e*f}                      |
|                                                        |
|o10 : List                                              |
+--------------------------------------------------------+

The shelling order is cached if it exists, however, if either option is used,
then the cache is ignored.

See also
========

  * isShellable -- determines whether a simplicial complex
    is shellable
  * isShelling -- determines whether a list of faces is a
    shelling

Ways to use shellingOrder:
==========================

  * "shellingOrder(SimplicialComplex)"

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

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

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

The source of this document is in SimplicialDecomposability.m2:893:0.