This is AbstractSimplicialComplexes.info, produced by Macaulay2, version 1.24.11

AbstractSimplicialComplexes -- a package for working with abstract simplicial complexes
***************************************************************************************

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

In this package our conventions are that `abstract simplicial complexes' have
vertices supported on the set [n] := {1,...,n}. Our aim is to provide a
methology for working with such objects directly. In this regard our approach
differs from that of the package SimplicialComplexes.m2. Here, we are
especially interested in homological aspects of SimplicialComplexes and our
approach is to implement such simplicial complexes as certain graded lists. In
particular, we provide methods for working with the chain complexes that are
associated to each abstract simplicial complex. We also give some functionality
for producing random simplicial complexes.

An overview of this package
===========================

  * How to make abstract simplicial complexes
    -- Using the type AbstractSimplicialComplexs to
    represent abstract simplicial complexes
  * How to make reduced and non-reduced simplicial chain complexes
    -- Simplicial
    homological constructors
  * Calculations with random simplicial complexes
    -- Homological calculations on random
    simplicial complexes

Author
======

  * Nathan Grieve (see https://sites.google.com/view/nathan-grieve )
    <nathan.m.grieve@gmail.com>

Version
=======

This documentation describes version 0.1 of AbstractSimplicialComplexes.

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

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

Exports
=======

  * Types
      * AbstractSimplicialComplex -- The type
        of all abstract simplicial complexes
  * Functions and commands
      * abstractSimplicialComplex -- The
        abstractSimplicialComplex that is determined by an abstract simplicial
        complex
      * abstractSimplicialComplexFacets,
        -- The facets of a simplicial complex
      * ambientAbstractSimplicialComplex
        -- The ambient simplex
      * ambientAbstractSimplicialComplexSize
        -- The ambient simplex size
      * inducedReducedSimplicialChainComplexMap
        -- Induced maps that arise via
        inclusions of abstract simplicial complexes
      * inducedSimplicialChainComplexMap
        -- Induced maps that arise via
        inclusions of abstract simplicial complexes
      * randomAbstractSimplicialComplex,
        -- Create a random simplicial set
      * randomSubSimplicialComplex -- Create
        a random sub-simplicial complex
      * reducedSimplicialChainComplex, --
        The reduced homological chain complex that is determined by an abstract
        simplicial complex
      * simplicialChainComplex -- The
        non-reduced homological chain complex that is determined by an abstract
        simplicial complex
  * Methods
      * "abstractSimplicialComplex(List)" -- see
        abstractSimplicialComplex, -- The
        abstractSimplicialComplex that is determined by an abstract simplicial
        complex
      * "abstractSimplicialComplex(ZZ)" -- see abstractSimplicialComplex,
        -- The abstractSimplicialComplex that is
        determined by an abstract simplicial complex
      * "abstractSimplicialComplex(ZZ,ZZ)" -- see
        abstractSimplicialComplex, -- The
        abstractSimplicialComplex that is determined by an abstract simplicial
        complex
      * AbstractSimplicialComplex == AbstractSimplicialComplex
        -- Decide if
        two simplicial complexes are equal
      * AbstractSimplicialComplex _ ZZ,
        -- The k faces of a simplicial complex
      * "abstractSimplicialComplexFacets(AbstractSimplicialComplex)" -- see
        abstractSimplicialComplexFacets,
        -- The facets of a simplicial complex
      * "ambientAbstractSimplicialComplex(AbstractSimplicialComplex)" -- see
        ambientAbstractSimplicialComplex,
        -- The ambient simplex
      * "ambientAbstractSimplicialComplexSize(AbstractSimplicialComplex)" --
        see ambientAbstractSimplicialComplexSize,
        -- The ambient simplex size
      * describe(AbstractSimplicialComplex)
        -- real description
      * dim(AbstractSimplicialComplex)
        -- The dimension of a simplicial
        complex
      * "inducedReducedSimplicialChainComplexMap(AbstractSimplicialComplex,
        AbstractSimplicialComplex)" -- see
        inducedReducedSimplicialChainComplexMap,
        -- Induced maps that arise via
        inclusions of abstract simplicial complexes
      * "inducedSimplicialChainComplexMap(AbstractSimplicialComplex,
        AbstractSimplicialComplex)" -- see
        inducedSimplicialChainComplexMap, --
        Induced maps that arise via inclusions of abstract simplicial complexes
      * new AbstractSimplicialComplex
      * "randomAbstractSimplicialComplex(ZZ)" -- see
        randomAbstractSimplicialComplex, --
        Create a random simplicial set
      * "randomAbstractSimplicialComplex(ZZ,ZZ)" -- see
        randomAbstractSimplicialComplex, --
        Create a random simplicial set
      * "randomAbstractSimplicialComplex(ZZ,ZZ,ZZ)" -- see
        randomAbstractSimplicialComplex, --
        Create a random simplicial set
      * "randomSubSimplicialComplex(AbstractSimplicialComplex)" -- see
        randomSubSimplicialComplex, -- Create a
        random sub-simplicial complex
      * "reducedSimplicialChainComplex(AbstractSimplicialComplex)" -- see
        reducedSimplicialChainComplex, -- The
        reduced homological chain complex that is determined by an abstract
        simplicial complex
      * "simplicialChainComplex(AbstractSimplicialComplex)" -- see
        simplicialChainComplex, -- The non-reduced
        homological chain complex that is determined by an abstract simplicial
        complex

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

The object AbstractSimplicialComplexes, is a package (Macaulay2Doc).

AbstractSimplicialComplex -- The type of all abstract simplicial complexes
**************************************************************************

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

The type AbstractSimplicialComplex is a data type for working with abstract
simplicial complexes with vertices supported on [n] = {1,...,n}.

Functions and methods returning an abstract simplicial complex:
===============================================================

  * "abstractSimplicialComplex(List)" -- see abstractSimplicialComplex,
    -- The abstractSimplicialComplex that is
    determined by an abstract simplicial complex
  * "abstractSimplicialComplex(ZZ)" -- see abstractSimplicialComplex,
    -- The abstractSimplicialComplex that is
    determined by an abstract simplicial complex
  * "abstractSimplicialComplex(ZZ,ZZ)" -- see abstractSimplicialComplex,
    -- The abstractSimplicialComplex that is
    determined by an abstract simplicial complex
  * AbstractSimplicialComplex _ ZZ, --
    The k faces of a simplicial complex
  * "ambientAbstractSimplicialComplex(AbstractSimplicialComplex)" -- see
    ambientAbstractSimplicialComplex, -- The
    ambient simplex
  * new AbstractSimplicialComplex
  * "randomAbstractSimplicialComplex(ZZ)" -- see
    randomAbstractSimplicialComplex, -- Create
    a random simplicial set
  * "randomAbstractSimplicialComplex(ZZ,ZZ)" -- see
    randomAbstractSimplicialComplex, -- Create
    a random simplicial set
  * "randomSubSimplicialComplex(AbstractSimplicialComplex)" -- see
    randomSubSimplicialComplex, -- Create a random
    sub-simplicial complex

Methods that use an abstract simplicial complex:
================================================

  * AbstractSimplicialComplex == AbstractSimplicialComplex
    -- Decide if two
    simplicial complexes are equal
  * "abstractSimplicialComplexFacets(AbstractSimplicialComplex)" -- see
    abstractSimplicialComplexFacets, -- The
    facets of a simplicial complex
  * "ambientAbstractSimplicialComplexSize(AbstractSimplicialComplex)" -- see
    ambientAbstractSimplicialComplexSize,
    -- The ambient simplex size
  * describe(AbstractSimplicialComplex)
    -- real description
  * dim(AbstractSimplicialComplex),
    -- The dimension of a simplicial complex
  * "inducedReducedSimplicialChainComplexMap(AbstractSimplicialComplex,
    AbstractSimplicialComplex)" -- see
    inducedReducedSimplicialChainComplexMap,
    -- Induced maps that arise via
    inclusions of abstract simplicial complexes
  * "inducedSimplicialChainComplexMap(AbstractSimplicialComplex,
    AbstractSimplicialComplex)" -- see inducedSimplicialChainComplexMap,
    -- Induced maps that arise via inclusions
    of abstract simplicial complexes
  * "reducedSimplicialChainComplex(AbstractSimplicialComplex)" -- see
    reducedSimplicialChainComplex, -- The
    reduced homological chain complex that is determined by an abstract
    simplicial complex
  * "simplicialChainComplex(AbstractSimplicialComplex)" -- see
    simplicialChainComplex, -- The non-reduced
    homological chain complex that is determined by an abstract simplicial
    complex

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

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

abstractSimplicialComplex -- The abstractSimplicialComplex that is determined by an abstract simplicial complex
***************************************************************************************************************

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

This method returns the AbstractSimplicialComplex that represents a given
abstract simplicial complex. The input is either a given collection of
generating faces or an integer. These facets need not be facets.  Moreover, the
elements of the faces need not be written in lexiographic order.  When the
input is an integer, the output is the corresponding simplex.

+-----------------------------------------------------------------------------+
|i1 : abstractSimplicialComplex({{1,2,3,4}})                                  |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
|4}}                                                                          |
+-----------------------------------------------------------------------------+
|i2 : abstractSimplicialComplex({{4,1,2,3}, {3,2,5},{1,5}})                   |
|                                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}}                |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o2 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                               }                                             |
|                                                                             |
|{2, 4}, {2, 5}, {3, 4}, {3, 5}}                                              |
|4}, {2, 3, 5}}                                                               |
+-----------------------------------------------------------------------------+
|i3 : abstractSimplicialComplex(4)                                            |
|                                                                             |
|o3 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o3 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
|4}}                                                                          |
+-----------------------------------------------------------------------------+

The simplicial complex on [n] with r-skelton can be constructed as follows.

+-----------------------------------------------------------------------------+
|i4 : abstractSimplicialComplex(4,2)                                          |
|                                                                             |
|o4 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                                                                             |
|o4 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
+-----------------------------------------------------------------------------+

Ways to use abstractSimplicialComplex:
======================================

  * "abstractSimplicialComplex(List)"
  * "abstractSimplicialComplex(ZZ)"
  * "abstractSimplicialComplex(ZZ,ZZ)"

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

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

AbstractSimplicialComplex == AbstractSimplicialComplex -- Decide if two simplicial complexes are equal
******************************************************************************************************

Synopsis
========

  * Operator: == (Macaulay2Doc),

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

Decides if two simplicial complexes are equal.

+-----------------------------------------------------------------------------+
|i1 : randomAbstractSimplicialComplex(4) == randomAbstractSimplicialComplex(4)|
|                                                                             |
|o1 = true                                                                    |
+-----------------------------------------------------------------------------+

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

  * AbstractSimplicialComplex == AbstractSimplicialComplex
    -- Decide if two
    simplicial complexes are equal

AbstractSimplicialComplex _ ZZ -- The k faces of a simplicial complex
*********************************************************************

Synopsis
========

  * Operator: _ (Macaulay2Doc),

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

This method returns the collection of k faces of a given
AbstractSimplicialComplex.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex(3)                        |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : K_3                                                     |
+-------------------------------------------------------------+
|i3 : K_2                                                     |
|                                                             |
|o3 = {{1, 2, 3}}                                             |
|                                                             |
|o3 : List                                                    |
+-------------------------------------------------------------+
|i4 : K_1                                                     |
|                                                             |
|o4 = {{1, 2}, {1, 3}, {2, 3}}                                |
|                                                             |
|o4 : List                                                    |
+-------------------------------------------------------------+
|i5 : K_0                                                     |
|                                                             |
|o5 = {{1}, {2}, {3}}                                         |
|                                                             |
|o5 : List                                                    |
+-------------------------------------------------------------+
|i6 : K_(-1)                                                  |
|                                                             |
|o6 = {{}}                                                    |
|                                                             |
|o6 : List                                                    |
+-------------------------------------------------------------+

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

  * AbstractSimplicialComplex _ ZZ, --
    The k faces of a simplicial complex

abstractSimplicialComplexFacets -- The facets of a simplicial complex
*********************************************************************

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

This method returns the collection of facets of a given
AbstractSimplicialComplex.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex(3)                        |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : abstractSimplicialComplexFacets K                       |
|                                                             |
|o2 = {{1, 2, 3}}                                             |
|                                                             |
|o2 : List                                                    |
+-------------------------------------------------------------+

Ways to use abstractSimplicialComplexFacets:
============================================

  * "abstractSimplicialComplexFacets(AbstractSimplicialComplex)"

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

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

ambientAbstractSimplicialComplex -- The ambient simplex
*******************************************************

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

If an abstract simplicial complex has vertices supported on a subset of [n] =
{1,...,n}, and including n, then it seems useful to regard this simplicial
complex as being a subsimplicial complex of the simplex on [n].  This method
returns this simplex as the ambient simplical complex.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2},{3}})              |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}          }         |
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}}                 |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : J = ambientAbstractSimplicialComplex(K)                 |
|                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o2 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+

Ways to use ambientAbstractSimplicialComplex:
=============================================

  * "ambientAbstractSimplicialComplex(AbstractSimplicialComplex)"

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

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

ambientAbstractSimplicialComplexSize -- The ambient simplex size
****************************************************************

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

If an abstract simplicial complex has vertices supported on a subset of [n] =
{1,...,n], and including n, then it seems useful to regard this simplicial
complex as being a subsimplicial complex of the simplex on [n].  This method
simply returns this largest integer n.

+----------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2},{3}})     |
|                                                    |
|o1 = AbstractSimplicialComplex{-1 => {{}}          }|
|                               0 => {{1}, {2}, {3}} |
|                               1 => {{1, 2}}        |
|                                                    |
|o1 : AbstractSimplicialComplex                      |
+----------------------------------------------------+
|i2 : J = ambientAbstractSimplicialComplexSize(K)    |
|                                                    |
|o2 = 3                                              |
+----------------------------------------------------+

Ways to use ambientAbstractSimplicialComplexSize:
=================================================

  * "ambientAbstractSimplicialComplexSize(AbstractSimplicialComplex)"

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

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

Calculations with random simplicial complexes -- Homological calculations on random simplicial complexes
********************************************************************************************************

In what follows we illustrate a collection of homological calculations that can
be performed on random simplicial complexes.

Create a random abstract simplicial complex with vertices supported on a subset
of [n] = {1,...,n}.

+-----------------------------------------------+
|i1 : setRandomSeed(currentTime());             |
+-----------------------------------------------+
|i2 : K = randomAbstractSimplicialComplex(4)    |
|                                               |
|o2 = AbstractSimplicialComplex{-1 => {{}}     }|
|                               0 => {{3}, {4}} |
|                               1 => {{3, 4}}   |
|                                               |
|o2 : AbstractSimplicialComplex                 |
+-----------------------------------------------+
|i3 : prune HH simplicialChainComplex K         |
|                                               |
|       1                                       |
|o3 = ZZ                                        |
|                                               |
|     0                                         |
|                                               |
|o3 : Complex                                   |
+-----------------------------------------------+

Create a random simplicial complex on [n] with dimension at most equal to r.

+-------------------------------------------------------------+
|i4 : setRandomSeed(currentTime());                           |
+-------------------------------------------------------------+
|i5 : L = randomAbstractSimplicialComplex(6,3)                |
|                                                             |
|o5 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{3}, {4}, {6}}          |
|                               1 => {{3, 4}, {3, 6}, {4, 6}} |
|                               2 => {{3, 4, 6}}              |
|                                                             |
|o5 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i6 : prune HH simplicialChainComplex L                       |
|                                                             |
|       1                                                     |
|o6 = ZZ                                                      |
|                                                             |
|     0                                                       |
|                                                             |
|o6 : Complex                                                 |
+-------------------------------------------------------------+

Create the random complex Y_d(n,m) which has vertex set [n] and complete (d −
1)-skeleton, and has exactly m dimension d faces, chosen at random from all
binomial(binomial(n,d+1),m) possibilities.

+-----------------------------------------------------------------------------+
|i7 : setRandomSeed(currentTime());                                           |
+-----------------------------------------------------------------------------+
|i8 : M = randomAbstractSimplicialComplex(6,3,2)                              |
|                                                                             |
|o8 = AbstractSimplicialComplex{-1 => {{}}                                   }|
|                               0 => {{2}, {4}, {5}, {6}}                     |
|                               1 => {{2, 4}, {2, 6}, {4, 5}, {4, 6}, {5, 6}} |
|                               2 => {{2, 4, 6}, {4, 5, 6}}                   |
|                                                                             |
|o8 : AbstractSimplicialComplex                                               |
+-----------------------------------------------------------------------------+
|i9 : prune HH simplicialChainComplex M                                       |
|                                                                             |
|       1                                                                     |
|o9 = ZZ                                                                      |
|                                                                             |
|     0                                                                       |
|                                                                             |
|o9 : Complex                                                                 |
+-----------------------------------------------------------------------------+

Creates a random sub-simplicial complex of a given simplicial complex.

+------------------------------------------------+
|i10 : setRandomSeed(currentTime());             |
+------------------------------------------------+
|i11 : K = randomAbstractSimplicialComplex(4)    |
|                                                |
|o11 = AbstractSimplicialComplex{-1 => {{}}     }|
|                                0 => {{3}, {4}} |
|                                1 => {{3, 4}}   |
|                                                |
|o11 : AbstractSimplicialComplex                 |
+------------------------------------------------+
|i12 : J = randomSubSimplicialComplex(K)         |
|                                                |
|o12 = AbstractSimplicialComplex{-1 => {{}}     }|
|                                0 => {{3}, {4}} |
|                                1 => {{3, 4}}   |
|                                                |
|o12 : AbstractSimplicialComplex                 |
+------------------------------------------------+
|i13 : inducedSimplicialChainComplexMap(K,J)     |
|                                                |
|            2                2                  |
|o13 = 0 : ZZ  <----------- ZZ  : 0              |
|                 | 1 0 |                        |
|                 | 0 1 |                        |
|                                                |
|            1              1                    |
|      1 : ZZ  <--------- ZZ  : 1                |
|                 | 1 |                          |
|                                                |
|o13 : ComplexMap                                |
+------------------------------------------------+

describe(AbstractSimplicialComplex) -- real description
*******************************************************

Synopsis
========

  * Function: describe (Macaulay2Doc),
  * Usage:
        describe S
  * Inputs:
      * an abstract simplicial complex,

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

see describe

See also
========

  * describe (Macaulay2Doc) -- real description

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

  * describe(AbstractSimplicialComplex)
    -- real description

dim(AbstractSimplicialComplex) -- The dimension of a simplicial complex
***********************************************************************

Synopsis
========

  * Function: dim (Macaulay2Doc),

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

This method returns the dimension a given AbstractSimplicialComplex.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex(3)                        |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : dim K                                                   |
|                                                             |
|o2 = 2                                                       |
+-------------------------------------------------------------+

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

  * dim(AbstractSimplicialComplex),
    -- The dimension of a simplicial complex

How to make abstract simplicial complexes -- Using the type AbstractSimplicialComplexs to represent abstract simplicial complexes
*********************************************************************************************************************************

The type AbstractSimplicialComplex is a data type for working with abstract
simplicial complexes with vertices supported on [n] = {1,...,n}. Here we
illustrate some of the most basic ways to interact with this data type.

The simplicial complex that is generated by {1,2,3,4}, {2,3,5} and {1,5} can be
constructed in the following way.

+-----------------------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2,3,4}, {2,3,5},{1,5}})               |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}}                |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                               }                                             |
|                                                                             |
|{2, 4}, {2, 5}, {3, 4}, {3, 5}}                                              |
|4}, {2, 3, 5}}                                                               |
+-----------------------------------------------------------------------------+

The simplex on the vertex set [4] can be constructed as

+-----------------------------------------------------------------------------+
|i2 : L = abstractSimplicialComplex(4)                                        |
|                                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o2 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
|4}}                                                                          |
+-----------------------------------------------------------------------------+

The faces and facets of such simplicial complexes can be accessed as

+-----------------------------------------------------------------------------+
|i3 : K_(-1)                                                                  |
|                                                                             |
|o3 = {{}}                                                                    |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : K_0                                                                     |
|                                                                             |
|o4 = {{1}, {2}, {3}, {4}, {5}}                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : K_1                                                                     |
|                                                                             |
|o5 = {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 4}, {2, 5}, {3, 4}, {3, 5}}|
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : K_2                                                                     |
|                                                                             |
|o6 = {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}, {2, 3, 5}}                 |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : abstractSimplicialComplexFacets K                                       |
|                                                                             |
|o7 = {{1, 5}, {2, 3, 5}, {1, 2, 3, 4}}                                       |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : L_(-1)                                                                  |
|                                                                             |
|o8 = {{}}                                                                    |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : L_0                                                                     |
|                                                                             |
|o9 = {{1}, {2}, {3}, {4}}                                                    |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : L_1                                                                    |
|                                                                             |
|o10 = {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}}                       |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : L_2                                                                    |
|                                                                             |
|o11 = {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}}                           |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+
|i12 : L_3                                                                    |
|                                                                             |
|o12 = {{1, 2, 3, 4}}                                                         |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+
|i13 : abstractSimplicialComplexFacets L                                      |
|                                                                             |
|o13 = {{1, 2, 3, 4}}                                                         |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+

How to make reduced and non-reduced simplicial chain complexes -- Simplicial homological constructors
*****************************************************************************************************

Non-reduced and reduced simplicial chain complexes can be constructed in the
following way.

+-----------------------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2,3,4}, {2,3,5},{1,5}})               |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}}                |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                               3 => {{1, 2, 3, 4}}                           |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                               }                                             |
|                                                                             |
|{2, 4}, {2, 5}, {3, 4}, {3, 5}}                                              |
|4}, {2, 3, 5}}                                                               |
+-----------------------------------------------------------------------------+
|i2 : k = simplicialChainComplex K                                            |
|                                                                             |
|       5       9       5       1                                             |
|o2 = ZZ  <-- ZZ  <-- ZZ  <-- ZZ                                              |
|                                                                             |
|     0       1       2       3                                               |
|                                                                             |
|o2 : Complex                                                                 |
+-----------------------------------------------------------------------------+
|i3 : k.dd                                                                    |
|                                                                             |
|           5                                       9                         |
|o3 = 0 : ZZ  <---------------------------------- ZZ  : 1                     |
|                | -1 -1 -1 -1 0  0  0  0  0  |                               |
|                | 1  0  0  0  -1 -1 -1 0  0  |                               |
|                | 0  1  0  0  1  0  0  -1 -1 |                               |
|                | 0  0  1  0  0  1  0  1  0  |                               |
|                | 0  0  0  1  0  0  1  0  1  |                               |
|                                                                             |
|           9                           5                                     |
|     1 : ZZ  <---------------------- ZZ  : 2                                 |
|                | 1  1  0  0  0  |                                           |
|                | -1 0  1  0  0  |                                           |
|                | 0  -1 -1 0  0  |                                           |
|                | 0  0  0  0  0  |                                           |
|                | 1  0  0  1  1  |                                           |
|                | 0  1  0  -1 0  |                                           |
|                | 0  0  0  0  -1 |                                           |
|                | 0  0  1  1  0  |                                           |
|                | 0  0  0  0  1  |                                           |
|                                                                             |
|           5               1                                                 |
|     2 : ZZ  <---------- ZZ  : 3                                             |
|                | -1 |                                                       |
|                | 1  |                                                       |
|                | -1 |                                                       |
|                | 1  |                                                       |
|                | 0  |                                                       |
|                                                                             |
|o3 : ComplexMap                                                              |
+-----------------------------------------------------------------------------+
|i4 : kRed = reducedSimplicialChainComplex K                                  |
|                                                                             |
|       1       5       9       5       1                                     |
|o4 = ZZ  <-- ZZ  <-- ZZ  <-- ZZ  <-- ZZ                                      |
|                                                                             |
|     -1      0       1       2       3                                       |
|                                                                             |
|o4 : Complex                                                                 |
+-----------------------------------------------------------------------------+
|i5 : kRed.dd                                                                 |
|                                                                             |
|            1                      5                                         |
|o5 = -1 : ZZ  <----------------- ZZ  : 0                                     |
|                 | 1 1 1 1 1 |                                               |
|                                                                             |
|           5                                       9                         |
|     0 : ZZ  <---------------------------------- ZZ  : 1                     |
|                | -1 -1 -1 -1 0  0  0  0  0  |                               |
|                | 1  0  0  0  -1 -1 -1 0  0  |                               |
|                | 0  1  0  0  1  0  0  -1 -1 |                               |
|                | 0  0  1  0  0  1  0  1  0  |                               |
|                | 0  0  0  1  0  0  1  0  1  |                               |
|                                                                             |
|           9                           5                                     |
|     1 : ZZ  <---------------------- ZZ  : 2                                 |
|                | 1  1  0  0  0  |                                           |
|                | -1 0  1  0  0  |                                           |
|                | 0  -1 -1 0  0  |                                           |
|                | 0  0  0  0  0  |                                           |
|                | 1  0  0  1  1  |                                           |
|                | 0  1  0  -1 0  |                                           |
|                | 0  0  0  0  -1 |                                           |
|                | 0  0  1  1  0  |                                           |
|                | 0  0  0  0  1  |                                           |
|                                                                             |
|           5               1                                                 |
|     2 : ZZ  <---------- ZZ  : 3                                             |
|                | -1 |                                                       |
|                | 1  |                                                       |
|                | -1 |                                                       |
|                | 1  |                                                       |
|                | 0  |                                                       |
|                                                                             |
|o5 : ComplexMap                                                              |
+-----------------------------------------------------------------------------+

How to make subsimplical complexes and induced simplicial chain complex maps -- Induced simplicial chain complex maps via subsimplicial complexes
*************************************************************************************************************************************************

Given a subsimplicial complex there are induced simplicial chain complex maps.
This is illustrated in the following way.

+-----------------------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex(4,3)                                      |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                               2 => {{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
|4}}                                                                          |
+-----------------------------------------------------------------------------+
|i2 : L = abstractSimplicialComplex(4,2)                                      |
|                                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}}                     |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, |
|                                                                             |
|o2 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
+-----------------------------------------------------------------------------+
|i3 : f = inducedSimplicialChainComplexMap(K,L)                               |
|                                                                             |
|           4                    4                                            |
|o3 = 0 : ZZ  <--------------- ZZ  : 0                                        |
|                | 1 0 0 0 |                                                  |
|                | 0 1 0 0 |                                                  |
|                | 0 0 1 0 |                                                  |
|                | 0 0 0 1 |                                                  |
|                                                                             |
|           6                        6                                        |
|     1 : ZZ  <------------------- ZZ  : 1                                    |
|                | 1 0 0 0 0 0 |                                              |
|                | 0 1 0 0 0 0 |                                              |
|                | 0 0 1 0 0 0 |                                              |
|                | 0 0 0 1 0 0 |                                              |
|                | 0 0 0 0 1 0 |                                              |
|                | 0 0 0 0 0 1 |                                              |
|                                                                             |
|o3 : ComplexMap                                                              |
+-----------------------------------------------------------------------------+
|i4 : isWellDefined f                                                         |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+
|i5 : fRed = inducedReducedSimplicialChainComplexMap(K,L)                     |
|                                                                             |
|            1              1                                                 |
|o5 = -1 : ZZ  <--------- ZZ  : -1                                            |
|                 | 1 |                                                       |
|                                                                             |
|           4                    4                                            |
|     0 : ZZ  <--------------- ZZ  : 0                                        |
|                | 1 0 0 0 |                                                  |
|                | 0 1 0 0 |                                                  |
|                | 0 0 1 0 |                                                  |
|                | 0 0 0 1 |                                                  |
|                                                                             |
|           6                        6                                        |
|     1 : ZZ  <------------------- ZZ  : 1                                    |
|                | 1 0 0 0 0 0 |                                              |
|                | 0 1 0 0 0 0 |                                              |
|                | 0 0 1 0 0 0 |                                              |
|                | 0 0 0 1 0 0 |                                              |
|                | 0 0 0 0 1 0 |                                              |
|                | 0 0 0 0 0 1 |                                              |
|                                                                             |
|o5 : ComplexMap                                                              |
+-----------------------------------------------------------------------------+
|i6 : isWellDefined fRed                                                      |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

inducedReducedSimplicialChainComplexMap -- Induced maps that arise via inclusions of abstract simplicial complexes
******************************************************************************************************************

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

If an abstract simplicial complex can be regarded as a subsimplicial complex of
another abstract simplicial complex, then it is useful to calculate the induced
map at the level of Reduced Simplicial Chain Complexes.  This is made possible
by the method inducedReducedSimplicialChainComplexMap.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2},{3}})              |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}          }         |
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}}                 |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : J = ambientAbstractSimplicialComplex(K)                 |
|                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o2 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i3 : inducedReducedSimplicialChainComplexMap(J,K)            |
|                                                             |
|            1              1                                 |
|o3 = -1 : ZZ  <--------- ZZ  : -1                            |
|                 | 1 |                                       |
|                                                             |
|           3                  3                              |
|     0 : ZZ  <------------- ZZ  : 0                          |
|                | 1 0 0 |                                    |
|                | 0 1 0 |                                    |
|                | 0 0 1 |                                    |
|                                                             |
|           3              1                                  |
|     1 : ZZ  <--------- ZZ  : 1                              |
|                | 1 |                                        |
|                | 0 |                                        |
|                | 0 |                                        |
|                                                             |
|o3 : ComplexMap                                              |
+-------------------------------------------------------------+
|i4 : L = abstractSimplicialComplex {{}}                      |
|                                                             |
|o4 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                                                             |
|o4 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i5 : inducedReducedSimplicialChainComplexMap(L,L)            |
|                                                             |
|o5 = -2 : 0 <----- 0 : -2                                    |
|               0                                             |
|                                                             |
|            1              1                                 |
|     -1 : ZZ  <--------- ZZ  : -1                            |
|                 | 1 |                                       |
|                                                             |
|o5 : ComplexMap                                              |
+-------------------------------------------------------------+
|i6 : M = abstractSimplicialComplex {{1}}                     |
|                                                             |
|o6 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                               0 => {{1}}                    |
|                                                             |
|o6 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i7 : L = abstractSimplicialComplex {{}}                      |
|                                                             |
|o7 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                                                             |
|o7 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i8 : inducedReducedSimplicialChainComplexMap(M,L)            |
|                                                             |
|o8 = -2 : 0 <----- 0 : -2                                    |
|               0                                             |
|                                                             |
|            1              1                                 |
|     -1 : ZZ  <--------- ZZ  : -1                            |
|                 | 1 |                                       |
|                                                             |
|o8 : ComplexMap                                              |
+-------------------------------------------------------------+

See also
========

  * inducedSimplicialChainComplexMap,
    -- Induced maps that arise via inclusions of abstract simplicial complexes

Ways to use inducedReducedSimplicialChainComplexMap:
====================================================

  * "inducedReducedSimplicialChainComplexMap(AbstractSimplicialComplex,
    AbstractSimplicialComplex)"

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

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

inducedSimplicialChainComplexMap -- Induced maps that arise via inclusions of abstract simplicial complexes
***********************************************************************************************************

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

If an abstract simplicial complex can be regarded as a subsimplicial complex of
another abstract simplicial complex, then it is useful to calculate the induced
map at the level of Simplicial Chain Complexes.  This is made possible by the
method inducedSimplicialChainComplexMap.

+-------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2},{3}})              |
|                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}          }         |
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}}                 |
|                                                             |
|o1 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i2 : J = ambientAbstractSimplicialComplex(K)                 |
|                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {2}, {3}}          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}} |
|                               2 => {{1, 2, 3}}              |
|                                                             |
|o2 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i3 : inducedSimplicialChainComplexMap(J,K)                   |
|                                                             |
|           3                  3                              |
|o3 = 0 : ZZ  <------------- ZZ  : 0                          |
|                | 1 0 0 |                                    |
|                | 0 1 0 |                                    |
|                | 0 0 1 |                                    |
|                                                             |
|           3              1                                  |
|     1 : ZZ  <--------- ZZ  : 1                              |
|                | 1 |                                        |
|                | 0 |                                        |
|                | 0 |                                        |
|                                                             |
|o3 : ComplexMap                                              |
+-------------------------------------------------------------+
|i4 : L = abstractSimplicialComplex {{}}                      |
|                                                             |
|o4 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                                                             |
|o4 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i5 : inducedSimplicialChainComplexMap(L,L)                   |
|                                                             |
|o5 = 0                                                       |
|                                                             |
|o5 : ComplexMap                                              |
+-------------------------------------------------------------+
|i6 : M = abstractSimplicialComplex {{1}}                     |
|                                                             |
|o6 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                               0 => {{1}}                    |
|                                                             |
|o6 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i7 : L = abstractSimplicialComplex {{}}                      |
|                                                             |
|o7 = AbstractSimplicialComplex{-1 => {{}}}                   |
|                                                             |
|o7 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+
|i8 : inducedSimplicialChainComplexMap(M,L)                   |
|                                                             |
|o8 = 0                                                       |
|                                                             |
|o8 : ComplexMap                                              |
+-------------------------------------------------------------+

See also
========

  * inducedReducedSimplicialChainComplexMap
    -- Induced maps that arise via
    inclusions of abstract simplicial complexes

Ways to use inducedSimplicialChainComplexMap:
=============================================

  * "inducedSimplicialChainComplexMap(AbstractSimplicialComplex,
    AbstractSimplicialComplex)"

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

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

new AbstractSimplicialComplex
*****************************

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

  * new AbstractSimplicialComplex

randomAbstractSimplicialComplex -- Create a random simplicial set
*****************************************************************

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

Create a random abstract simplicial complex with vertices supported on a subset
of [n] = {1,...,n}.

+-----------------------------------------------+
|i1 : setRandomSeed(currentTime());             |
+-----------------------------------------------+
|i2 : K = randomAbstractSimplicialComplex(4)    |
|                                               |
|o2 = AbstractSimplicialComplex{-1 => {{}}     }|
|                               0 => {{1}, {4}} |
|                               1 => {{1, 4}}   |
|                                               |
|o2 : AbstractSimplicialComplex                 |
+-----------------------------------------------+

Create a random simplicial complex on [n] with dimension at most equal to r.

+-------------------------------------------------------------+
|i3 : setRandomSeed(currentTime());                           |
+-------------------------------------------------------------+
|i4 : L = randomAbstractSimplicialComplex(6,3)                |
|                                                             |
|o4 = AbstractSimplicialComplex{-1 => {{}}                   }|
|                               0 => {{1}, {5}, {6}}          |
|                               1 => {{1, 5}, {1, 6}, {5, 6}} |
|                               2 => {{1, 5, 6}}              |
|                                                             |
|o4 : AbstractSimplicialComplex                               |
+-------------------------------------------------------------+

Create the random complex Y_d(n,m) which has vertex set [n] and complete (d −
1)-skeleton, and has exactly m d-dimensional faces, chosen at random from all
binomial(binomial(n,d+1),m) possibilities.

+-----------------------------------------------------------------------------+
|i5 : setRandomSeed(currentTime());                                           |
+-----------------------------------------------------------------------------+
|i6 : M = randomAbstractSimplicialComplex(6,3,2)                              |
|                                                                             |
|o6 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {4}, {5}, {6}}                |
|                               1 => {{1, 2}, {1, 4}, {1, 5}, {1, 6}, {2, 5}, |
|                               2 => {{1, 2, 5}, {1, 4, 6}, {1, 5, 6}}        |
|                                                                             |
|o6 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|               }                                                             |
|                                                                             |
|{4, 6}, {5, 6}}                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * random (Macaulay2Doc) -- get a random object
  * randomSquareFreeMonomialIdeal (missing documentation)

Ways to use randomAbstractSimplicialComplex:
============================================

  * "randomAbstractSimplicialComplex(ZZ)"
  * "randomAbstractSimplicialComplex(ZZ,ZZ)"
  * "randomAbstractSimplicialComplex(ZZ,ZZ,ZZ)"

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

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

randomSubSimplicialComplex -- Create a random sub-simplicial complex
********************************************************************

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

Creates a random sub-simplicial complex of a given simplicial complex.

+-----------------------------------------------+
|i1 : setRandomSeed(currentTime());             |
+-----------------------------------------------+
|i2 : K = randomAbstractSimplicialComplex(4)    |
|                                               |
|o2 = AbstractSimplicialComplex{-1 => {{}}     }|
|                               0 => {{2}, {3}} |
|                               1 => {{2, 3}}   |
|                                               |
|o2 : AbstractSimplicialComplex                 |
+-----------------------------------------------+
|i3 : J = randomSubSimplicialComplex(K)         |
|                                               |
|o3 = AbstractSimplicialComplex{-1 => {{}}     }|
|                               0 => {{2}, {3}} |
|                               1 => {{2, 3}}   |
|                                               |
|o3 : AbstractSimplicialComplex                 |
+-----------------------------------------------+

Ways to use randomSubSimplicialComplex:
=======================================

  * "randomSubSimplicialComplex(AbstractSimplicialComplex)"

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

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

reducedSimplicialChainComplex -- The reduced homological chain complex that is determined by an abstract simplicial complex
***************************************************************************************************************************

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

This method returns the reduced homological chain complex (i.e., there is a
nonzero term in homological degree -1 that corresponds to the empty face) that
is associated to an abstract simplicial complex.  The chain complex is defined
over the integers.

+-----------------------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2,3},{2,4,9},{1,2,3,5,7,8},{3,4}})    |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {7}, {8}, {9}} |
|                               1 => {{1, 2}, {1, 3}, {1, 5}, {1, 7}, {1, 8}, |
|                               2 => {{1, 2, 3}, {1, 2, 5}, {1, 2, 7}, {1, 2, |
|                               3 => {{1, 2, 3, 5}, {1, 2, 3, 7}, {1, 2, 3, 8 |
|                               4 => {{1, 2, 3, 5, 7}, {1, 2, 3, 5, 8}, {1, 2 |
|                               5 => {{1, 2, 3, 5, 7, 8}}                     |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
| {2, 3}, {2, 4}, {2, 5}, {2, 7}, {2, 8}, {2, 9}, {3, 4}, {3, 5}, {3, 7}, {3, |
| 8}, {1, 3, 5}, {1, 3, 7}, {1, 3, 8}, {1, 5, 7}, {1, 5, 8}, {1, 7, 8}, {2, 3,|
|}, {1, 2, 5, 7}, {1, 2, 5, 8}, {1, 2, 7, 8}, {1, 3, 5, 7}, {1, 3, 5, 8}, {1, |
|, 3, 7, 8}, {1, 2, 5, 7, 8}, {1, 3, 5, 7, 8}, {2, 3, 5, 7, 8}}               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|8}, {4, 9}, {5, 7}, {5, 8}, {7, 8}}                                          |
| 5}, {2, 3, 7}, {2, 3, 8}, {2, 4, 9}, {2, 5, 7}, {2, 5,                      |
|3, 7, 8}, {1, 5, 7, 8}, {2, 3, 5, 7}, {2, 3, 5, 8}, {2,                      |
|-----------------------------------------------------------------------------|
|                                                          }                  |
|                                                                             |
|                                                                             |
|8}, {2, 7, 8}, {3, 5, 7}, {3, 5, 8}, {3, 7, 8}, {5, 7, 8}}                   |
|3, 7, 8}, {2, 5, 7, 8}, {3, 5, 7, 8}}                                        |
+-----------------------------------------------------------------------------+
|i2 : reducedSimplicialChainComplex(K)                                        |
|                                                                             |
|       1       8       19       21       15       6       1                  |
|o2 = ZZ  <-- ZZ  <-- ZZ   <-- ZZ   <-- ZZ   <-- ZZ  <-- ZZ                   |
|                                                                             |
|     -1      0       1        2        3        4       5                    |
|                                                                             |
|o2 : Complex                                                                 |
+-----------------------------------------------------------------------------+

Ways to use reducedSimplicialChainComplex:
==========================================

  * "reducedSimplicialChainComplex(AbstractSimplicialComplex)"

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

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

simplicialChainComplex -- The non-reduced homological chain complex that is determined by an abstract simplicial complex
************************************************************************************************************************

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

This method returns the (non-reduced) homological chain complex (i.e., there is
no nonzero term in homological degree -1 that corresponds to the empty face)
that is associated to an abstract simplicial complex.  The chain complex is
defined over the integers.

+-----------------------------------------------------------------------------+
|i1 : K = abstractSimplicialComplex({{1,2,3},{1,4,5},{2,4,5,7}})              |
|                                                                             |
|o1 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {7}}           |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, |
|                               2 => {{1, 2, 3}, {1, 4, 5}, {2, 4, 5}, {2, 4, |
|                               3 => {{2, 4, 5, 7}}                           |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                               }                             |
|                                                                             |
|{2, 4}, {2, 5}, {2, 7}, {4, 5}, {4, 7}, {5, 7}}                              |
|7}, {2, 5, 7}, {4, 5, 7}}                                                    |
+-----------------------------------------------------------------------------+
|i2 : C = simplicialChainComplex(K)                                           |
|                                                                             |
|       6       11       6       1                                            |
|o2 = ZZ  <-- ZZ   <-- ZZ  <-- ZZ                                             |
|                                                                             |
|     0       1        2       3                                              |
|                                                                             |
|o2 : Complex                                                                 |
+-----------------------------------------------------------------------------+

Ways to use simplicialChainComplex:
===================================

  * "simplicialChainComplex(AbstractSimplicialComplex)"

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

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