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

SimplicialPosets -- A package for working with simplicial posets.
*****************************************************************

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

The primary purpose of this package is to implement the simplicial poset ring
as defined by Richard P. Stanley in 1989.

Stanley's original paper. (see
https://www.semanticscholar.org/paper/f-vectors-and-h-vectors-of-simplicial-
posets-Stanley/2787117152700af2abce3126dd7ba2325685d78b )

Acknowledgements:

This package uses some code from the  Posets, package.

Thanks to Victor Reiner (see http://www-users.math.umn.edu/~reiner/ ). This
project was his idea.

Author
======

  * Nathan Nichols <nicho997@umn.edu>

Version
=======

This documentation describes version 1.0 of SimplicialPosets.

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

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

Exports
=======

  * Functions and commands
      * fromFVector -- If possible, returns a simplicial
        poset with the given f-vector.
      * getFVector -- Returns the f-vector
        {f_{-1},f_0,...,f_{d-1}} of the given poset.
      * isBoolean -- Determine if a poset is a boolean
        algebra.
      * stanleyPosetIdeal -- Returns ideal that
        defines the simplicial poset ring of the given simplicial poset.
      * testFVector -- Tests if it is possible for a
        simplicial poset to have a given f-vector.
  * Methods
      * "fromFVector(List)" -- see fromFVector, -- If
        possible, returns a simplicial poset with the given f-vector.
      * "getFVector(Poset)" -- see getFVector, -- Returns the
        f-vector {f_{-1},f_0,...,f_{d-1}} of the given poset.
      * "isBoolean(Poset)" -- see isBoolean, -- Determine if a
        poset is a boolean algebra.
      * "isSimplicial(Poset)" -- see isSimplicial, --
        Determine if a poset is simplicial.
      * "stanleyPosetIdeal(Poset)" -- see stanleyPosetIdeal,
        -- Returns ideal that defines the simplicial poset
        ring of the given simplicial poset.
      * "testFVector(List)" -- see testFVector, -- Tests if
        it is possible for a simplicial poset to have a given f-vector.

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

The object SimplicialPosets, is a package (Macaulay2Doc).

Example: Calculating a Stanley simplicial poset ring
****************************************************

The following is an example of the basic task that this package was written to
accomplish.

+-----------------------------------------------------------------------------+
|i1 : P = fromFVector({1,6,5,1});                                             |
+-----------------------------------------------------------------------------+
|i2 : I = stanleyPosetIdeal(P);                                               |
|                                                                             |
|o2 : Ideal of QQ[x   , x   , x   , x   , x   , x   , x   , x   , x , x , x , |
|                  000   001   010   011   100   101   110   111   1   2   3  |
|-----------------------------------------------------------------------------|
|x , x ]                                                                      |
| 4   5                                                                       |
+-----------------------------------------------------------------------------+
|i3 : R = ring(I)/I;                                                          |
+-----------------------------------------------------------------------------+
|i4 : getFVector(P)                                                           |
|                                                                             |
|o4 = {1, 6, 5, 1}                                                            |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : isSimplicial(P)                                                         |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * stanleyPosetIdeal -- Returns ideal that defines
    the simplicial poset ring of the given simplicial poset.

fromFVector -- If possible, returns a simplicial poset with the given f-vector.
*******************************************************************************

Synopsis
========

  * Usage:
        P = fromFVector(L)
  * Inputs:
      * L, a list (Macaulay2Doc), The desired F-vector.
  * Outputs:
      * P, an instance of the type Poset (Posets), A simplicial
        poset with f-vector L.

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

This method is provided as a way to construct an example of a simplicial poset
with a given f-vector.

It implements a construction due to Richard Stanley.

For details about this construction and a description of what f-vectors can be
constructed, see Stanley's original paper. (see
https://www.semanticscholar.org/paper/f-vectors-and-h-vectors-of-simplicial-
posets-Stanley/2787117152700af2abce3126dd7ba2325685d78b )

+--------------------------------+
|i1 : P = fromFVector({1,6,5,1});|
+--------------------------------+
|i2 : isSimplicial(P)            |
|                                |
|o2 = true                       |
+--------------------------------+
|i3 : getFVector(P)              |
|                                |
|o3 = {1, 6, 5, 1}               |
|                                |
|o3 : List                       |
+--------------------------------+

Ways to use fromFVector :
=========================

  * "fromFVector(List)"

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

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

getFVector -- Returns the f-vector {f_{-1},f_0,...,f_{d-1}} of the given poset.
*******************************************************************************

Synopsis
========

  * Usage:
        L = getFVector(P)
  * Inputs:
      * P, an instance of the type Poset (Posets), A poset.
  * Outputs:
      * L, a list (Macaulay2Doc), The f-vector
        {f_-1,f_0,...,f_{d-1}} of the poset P.

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

This is a wrapper around the rankGeneratingFunction (Posets),
method from the Posets,
package.

+--------------------------------+
|i1 : P = fromFVector({1,6,5,1});|
+--------------------------------+
|i2 : L = getFVector(P)          |
|                                |
|o2 = {1, 6, 5, 1}               |
|                                |
|o2 : List                       |
+--------------------------------+

Ways to use getFVector :
========================

  * "getFVector(Poset)"

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

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

isBoolean -- Determine if a poset is a boolean algebra.
*******************************************************

Synopsis
========

  * Usage:
        r = isBoolean(P)
  * Inputs:
      * P, an instance of the type Poset (Posets), The poset to be
        tested
  * Outputs:
      * r, a Boolean value (Macaulay2Doc), Whether the given
        poset is a boolean algebra or not

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

Every finite boolean algebra is atomic and the number of atoms determines its
isomorphism class.

This makes it possible to use the atoms (Posets), method to
determine the necessary isomorphism class of P and use the areIsomorphic (Posets),
method to check if the required isomorphism holds.

+---------------------------+
|i1 : P = booleanLattice(3);|
+---------------------------+
|i2 : isBoolean(P)          |
|                           |
|o2 = true                  |
+---------------------------+

Ways to use isBoolean :
=======================

  * "isBoolean(Poset)"

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

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

isSimplicial -- Determine if a poset is simplicial.
***************************************************

Synopsis
========

  * Usage:
        r = isSimplicial(P)
  * Inputs:
      * P, an instance of the type Poset (Posets), The poset to be
        tested
  * Outputs:
      * r, a Boolean value (Macaulay2Doc), Whether the given
        poset is simplicial or not

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

This method uses the isBoolean, method to check that every
closed interval of P is a boolean algebra.

+---------------------------+
|i1 : P = booleanLattice(3);|
+---------------------------+
|i2 : isSimplicial(P)       |
|                           |
|o2 = true                  |
+---------------------------+

Ways to use isSimplicial :
==========================

  * "isSimplicial(PolyhedralObject)" -- see isSimplicial (Polyhedra),
    --  checks if a polyhedral object is simplicial
  * "isSimplicial(Poset)"

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

The object isSimplicial (Polyhedra), is a method function (Macaulay2Doc).

stanleyPosetIdeal -- Returns ideal that defines the simplicial poset ring of the given simplicial poset.
********************************************************************************************************

Synopsis
========

  * Usage:
        I = stanleyPosetIdeal(P)
  * Inputs:
      * P, an instance of the type Poset (Posets), A simplicial
        poset.
  * Outputs:
      * I, an ideal (Macaulay2Doc), An ideal such that ring(I)/I
        is the simplicial poset ring of P.

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

For details about the definition of this ideal, refer to Stanley's original
paper, (see https://www.semanticscholar.org/paper/f-vectors-and-h-vectors-of-
simplicial-posets-Stanley/2787117152700af2abce3126dd7ba2325685d78b )
specifically definition 3.3.

+----------------------------------------------------------------+
|i1 : P = booleanLattice(3);                                     |
+----------------------------------------------------------------+
|i2 : I = stanleyPosetIdeal(P);                                  |
|                                                                |
|o2 : Ideal of QQ[x   , x   , x   , x   , x   , x   , x   , x   ]|
|                  000   001   010   011   100   101   110   111 |
+----------------------------------------------------------------+
|i3 : SPR := ring(I)/I;                                          |
+----------------------------------------------------------------+

Ways to use stanleyPosetIdeal :
===============================

  * "stanleyPosetIdeal(Poset)"

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

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

testFVector -- Tests if it is possible for a simplicial poset to have a given f-vector.
***************************************************************************************

Synopsis
========

  * Usage:
        B = testFVector(L)
  * Inputs:
      * L, a list (Macaulay2Doc), The f-vector to test.
  * Outputs:
      * B, a Boolean value (Macaulay2Doc), Whether a poset with
        the given f-vector exists.

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

See Stanley's paper (see https://www.semanticscholar.org/paper/f-vectors-and-h-
vectors-of-simplicial-posets-Stanley/2787117152700af2abce3126dd7ba2325685d78b )
for more details about what f-vectors a simplicial poset can have.

This is useful for validating the arguments of a function that takes an
f-vector.

+-----------------------------+
|i1 : testFVector({1,4,6,4,1})|
|                             |
|o1 = true                    |
+-----------------------------+

Ways to use testFVector :
=========================

  * "testFVector(List)"

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

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