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

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

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

The package AbstractSimplicialComplexes provides a methodology for working with
abstract simplicial complexes.  The starting point is to represent each
abstract simplicial complex as a graded list.  In this regard our approach
differs fundamentally from that of the package SimplicialComplexes.

In this package our conventions are that abstract simplicial complexes have
vertices supported on the set $[n] := \{1,\dots,n\}$.  Users who wish to use
the package to study simplicial complexes on vertex sets different from $[n]$
should first fix a suitable order preserving bijection which is compatible with
the standard lexicographic ordering.

Here, we are especially interested in homological aspects of abstract
simplicial complexes 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
===========================

For an overview of how to use this package, see

  * How to make abstract simplicial complexes
  * How to make reduced and non-reduced simplicial chain complexes
  * Calculations with random simplicial complexes

Mathematical background, motivation, conventions and notations
==============================================================

Our conventions for abstract simplicial complexes, their associated boundary
maps, reduced and non-reduced chain complexes are similar to those of the texts

  * Combinatorial commutative algebra (see
    https://www.springer.com/gp/book/9780387223568 ) by E. Miller and B.
    Sturmfels [Springer-Verlag, (2005)]
  * Basic Topology (see https://link.springer.com/book/10.1007/978-1-4757-1793-
    8 ) by M. A. Armstrong [Springer-Verlag (1983)]
  * Cohen-Macaulay rings (see
    https://www.cambridge.org/core/books/cohenmacaulay-rings/
    938BC2204D8A7C99E2CEBA1695A692A4 ) by W. Bruns and J. Herzog [Cambridge
    University Press (1993)]

and others.

This package also has strong motivation from and interplay with Topological
Data Analysis. We refer to the works

  * Topology and data (see https://www.ams.org/journals/bull/2009-46-02/S0273-
    0979-09-01249-X/ ) by G. Carlsson [Bull. Amer. Math. Soc. vol. 46, no. 2
    (2009)]
  * Topological data analysis with applications (see
    https://www.cambridge.org/core/books/topological-data-analysis-with-
    applications/00B93B496EBB97FB6E7A9CA0176F0E12 ) by G. Carlsson and M.
    Vejdemo-Johansson [Cambridge University Press (2022)]

and the references therein for further details about abstract simplicial
complexes within the context of Topological Data Analysis.

This package also provides constructors for producing certain classes of random
simplicial complexes. We refer to the work

  * Cohen-Lenstra heuristics for torsion in homology of random complexes (see
    https://www.tandfonline.com/doi/abs/10.1080/10586458.2018.1473821 ) by  M.
    Kahle, F. H. Lutz, A. Newman, and K. Parsons [Exp. Math. vol. 29, no. 3
    (2020)]

and the references therein for further details about constructing random
simplicial complexes.

Author
======

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

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

Version 1.0 of this package was accepted for publication in volume 15 (see
https://msp.org/jsag/2025/15-1/ ) of Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 2025-04-14, in the article Abstract
simplicial complexes in Macaulay2 (see https://msp.org/jsag/2025/15-1/p03.xhtml
) (DOI: 10.2140/jsag.2025.15.29 (see https://doi.org/10.2140/jsag.2025.15.29
)). That version can be obtained from the journal (see
https://msp.org/jsag/2025/15-1/jsag-v15-n1-x03-AbstractSimplicialComplexes.m2
).

Version
=======

This documentation describes version 1.1 of AbstractSimplicialComplexes,
released 12 May 2025.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{AbstractSimplicialComplexesSource,                                     |
|  title = {{AbstractSimplicialComplexes: A \emph{Macaulay2} package. Version~|
|  author = {Nathan Grieve},                                                  |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
|@article{AbstractSimplicialComplexesArticle,                                 |
|  title = {{Abstract simplicial complexes in \emph{Macaulay2}}},             |
|  author = {Nathan Grieve},                                                  |
|  journal = {Journal of Software for Algebra and Geometry},                  |
|  volume = {15},                                                             |
|  year = {2025},                                                             |
|}                                                                            |
|-----------------------------------------------------------------------------|
|1.1}},                                                                       |
+-----------------------------------------------------------------------------+

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
        -- the induced maps that arise
        via inclusions of abstract simplicial complexes
      * inducedSimplicialChainComplexMap
        -- the induced maps that arise via
        inclusions of abstract simplicial complexes
      * randomAbstractSimplicialComplex,
        -- create a random abstract simplicial complex
      * randomSubSimplicialComplex -- create
        a random subsimplicial 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,
        -- the induced maps that arise
        via inclusions of abstract simplicial complexes
      * "inducedSimplicialChainComplexMap(AbstractSimplicialComplex,
        AbstractSimplicialComplex)" -- see
        inducedSimplicialChainComplexMap, --
        the induced maps that arise via inclusions of abstract simplicial
        complexes
      * new AbstractSimplicialComplex
      * "randomAbstractSimplicialComplex(ZZ)" -- see
        randomAbstractSimplicialComplex, --
        create a random abstract simplicial complex
      * "randomAbstractSimplicialComplex(ZZ,ZZ)" -- see
        randomAbstractSimplicialComplex, --
        create a random abstract simplicial complex
      * "randomAbstractSimplicialComplex(ZZ,ZZ,ZZ)" -- see
        randomAbstractSimplicialComplex, --
        create a random abstract simplicial complex
      * "randomSubSimplicialComplex(AbstractSimplicialComplex)" -- see
        randomSubSimplicialComplex, -- create a
        random subsimplicial 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),
defined in AbstractSimplicialComplexes.m2.

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

The source of this document is in AbstractSimplicialComplexes.m2:451:0.

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,\dots,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 abstract simplicial complex
  * "randomAbstractSimplicialComplex(ZZ,ZZ)" -- see
    randomAbstractSimplicialComplex, -- create
    a random abstract simplicial complex
  * "randomAbstractSimplicialComplex(ZZ,ZZ,ZZ)" -- see
    randomAbstractSimplicialComplex, -- create
    a random abstract simplicial complex
  * "randomSubSimplicialComplex(AbstractSimplicialComplex)" -- see
    randomSubSimplicialComplex, -- create a random
    subsimplicial 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,
    -- the induced maps that arise via
    inclusions of abstract simplicial complexes
  * "inducedSimplicialChainComplexMap(AbstractSimplicialComplex,
    AbstractSimplicialComplex)" -- see inducedSimplicialChainComplexMap,
    -- the 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).

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

The source of this document is in AbstractSimplicialComplexes.m2:604:0.

abstractSimplicialComplex -- the AbstractSimplicialComplex that is determined by an abstract simplicial complex
***************************************************************************************************************

  * Usage:
        abstractSimplicialComplex(l)
        abstractSimplicialComplex(n)
        abstractSimplicialComplex(n,r)
  * Inputs:
      * l, a list (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
      * r, an integer (Macaulay2Doc),
  * Outputs:
      * 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 faces need not be facets.  Moreover, the
elements of the faces need not be written in lexicographic order.  When the
input is an integer $n$, the output is the corresponding simplex on $[n]$.
When the input is a pair of integers, $(n,r)$ the output is the simplicial
complex on $[n]$ with complete $r$-skeleton.

+-----------------------------------------------------------------------------+
|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 complete $r$-skeleton 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).

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

The source of this document is in AbstractSimplicialComplexes.m2:905:0.

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

  * Operator: == (Macaulay2Doc),
  * Usage:
        K == L
  * Inputs:
      * K, an abstract simplicial complex,
      * L, an abstract simplicial complex,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Decides if two simplicial complexes are equal.

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

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

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

The source of this document is in AbstractSimplicialComplexes.m2:634:0.

AbstractSimplicialComplex _ ZZ -- the $k$ faces of a simplicial complex
***********************************************************************

  * Operator: _ (Macaulay2Doc),
  * Usage:
        K_k
  * Inputs:
      * K, an abstract simplicial complex,
      * k, an integer (Macaulay2Doc),
  * Outputs:
      * an abstract simplicial complex, the
        list of $k$ faces

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                                                     |
|                                                             |
|o2 = {}                                                      |
|                                                             |
|o2 : List                                                    |
+-------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:931:0.

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

  * Usage:
        abstractSimplicialComplexFacets(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * the list of facets

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                                                    |
+-------------------------------------------------------------+
|i3 : facets K                                                |
|                                                             |
|o3 = {{1, 2, 3}}                                             |
|                                                             |
|o3 : List                                                    |
+-------------------------------------------------------------+

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

  * "abstractSimplicialComplexFacets(AbstractSimplicialComplex)"

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

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

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

The source of this document is in AbstractSimplicialComplexes.m2:954:0.

ambientAbstractSimplicialComplex -- the ambient simplex
*******************************************************

  * Usage:
        ambientAbstractSimplicialComplex(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * an abstract simplicial complex,

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

If an abstract simplicial complex has vertices supported on a subset of $[n] =
\{1,\dots,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 simplicial 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).

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

The source of this document is in AbstractSimplicialComplexes.m2:735:0.

ambientAbstractSimplicialComplexSize -- the ambient simplex size
****************************************************************

  * Usage:
        ambientAbstractSimplicialComplex(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * an integer (Macaulay2Doc),

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

If an abstract simplicial complex has vertices supported on a subset of $[n] =
\{1,\dots,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).

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

The source of this document is in AbstractSimplicialComplexes.m2:758:0.

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 : K = randomAbstractSimplicialComplex(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}}                   |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
+-----------------------------------------------------------------------------+
|i2 : prune HH simplicialChainComplex K                                       |
|                                                                             |
|       1       1                                                             |
|o2 = ZZ  <-- ZZ                                                              |
|                                                                             |
|     0       1                                                               |
|                                                                             |
|o2 : Complex                                                                 |
+-----------------------------------------------------------------------------+

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

+-----------------------------------------------------------------------------+
|i3 : L = randomAbstractSimplicialComplex(6,3)                                |
|                                                                             |
|o3 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {6}}           |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, |
|                               2 => {{1, 2, 3}, {1, 2, 5}, {1, 2, 6}, {1, 3, |
|                                                                             |
|o3 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|{2, 3}, {2, 4}, {2, 5}, {2, 6}, {3, 4}, {3, 5}, {3,                          |
|4}, {1, 4, 6}, {2, 3, 6}, {2, 4, 6}, {2, 5, 6}, {3,                          |
|-----------------------------------------------------------------------------|
|                            }                                                |
|                                                                             |
|6}, {4, 5}, {4, 6}, {5, 6}}                                                  |
|4, 5}, {3, 5, 6}, {4, 5, 6}}                                                 |
+-----------------------------------------------------------------------------+
|i4 : prune HH simplicialChainComplex L                                       |
|                                                                             |
|       1             1                                                       |
|o4 = ZZ  <-- 0 <-- ZZ                                                        |
|                                                                             |
|     0       1     2                                                         |
|                                                                             |
|o4 : Complex                                                                 |
+-----------------------------------------------------------------------------+

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

+-----------------------------------------------------------------------------+
|i5 : M = randomAbstractSimplicialComplex(6,3,2)                              |
|                                                                             |
|o5 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {6}}           |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, |
|                               2 => {{2, 3, 4}, {3, 5, 6}, {4, 5, 6}}        |
|                                                                             |
|o5 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|{2, 3}, {2, 4}, {2, 5}, {2, 6}, {3, 4}, {3, 5}, {3, 6}, {4, 5}, {4, 6}, {5,  |
|-----------------------------------------------------------------------------|
|   }                                                                         |
|                                                                             |
|6}}                                                                          |
+-----------------------------------------------------------------------------+
|i6 : prune HH simplicialChainComplex M                                       |
|                                                                             |
|       1       7                                                             |
|o6 = ZZ  <-- ZZ                                                              |
|                                                                             |
|     0       1                                                               |
|                                                                             |
|o6 : Complex                                                                 |
+-----------------------------------------------------------------------------+
|i7 : N = randomAbstractSimplicialComplex(6,3,2,Verify => true)               |
|                                                                             |
|o7 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {6}}           |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, |
|                               2 => {{1, 2, 5}, {1, 3, 6}, {2, 4, 5}}        |
|                                                                             |
|o7 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|{2, 3}, {2, 4}, {2, 5}, {2, 6}, {3, 4}, {3, 5}, {3, 6}, {4, 5}, {4, 6}, {5,  |
|-----------------------------------------------------------------------------|
|   }                                                                         |
|                                                                             |
|6}}                                                                          |
+-----------------------------------------------------------------------------+

Creates a random subsimplicial complex of a given simplicial complex.

+-----------------------------------------------------------------------------+
|i8 : K = randomAbstractSimplicialComplex(4)                                  |
|                                                                             |
|o8 = 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}}                           |
|                                                                             |
|o8 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
|4}}                                                                          |
+-----------------------------------------------------------------------------+
|i9 : J = randomSubSimplicialComplex(K)                                       |
|                                                                             |
|o9 = AbstractSimplicialComplex{-1 => {{}}     }                              |
|                               0 => {{2}, {3}}                               |
|                               1 => {{2, 3}}                                 |
|                                                                             |
|o9 : AbstractSimplicialComplex                                               |
+-----------------------------------------------------------------------------+
|i10 : inducedSimplicialChainComplexMap(K,J)                                  |
|                                                                             |
|            4                2                                               |
|o10 = 0 : ZZ  <----------- ZZ  : 0                                           |
|                 | 0 0 |                                                     |
|                 | 1 0 |                                                     |
|                 | 0 1 |                                                     |
|                 | 0 0 |                                                     |
|                                                                             |
|            6              1                                                 |
|      1 : ZZ  <--------- ZZ  : 1                                             |
|                 | 0 |                                                       |
|                 | 0 |                                                       |
|                 | 0 |                                                       |
|                 | 1 |                                                       |
|                 | 0 |                                                       |
|                 | 0 |                                                       |
|                                                                             |
|o10 : ComplexMap                                                             |
+-----------------------------------------------------------------------------+

See also
========

  * randomAbstractSimplicialComplex, --
    create a random abstract simplicial complex
  * randomSubSimplicialComplex -- create a
    random subsimplicial complex
  * random (Macaulay2Doc) -- get a random object
  * RandomIdeals -- A package to construct various
    sorts of random ideals
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:582:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:987:0.

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

  * Function: dim (Macaulay2Doc),
  * Usage:
        dim(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * an integer (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
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:973:0.

How to make abstract simplicial complexes -- using the type AbstractSimplicialComplexes to represent abstract simplicial complexes
**********************************************************************************************************************************

The type AbstractSimplicialComplex is a data type for working with abstract
simplicial complexes with vertices supported on $[n] = \{1,\dots ,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                                                                   |
+-----------------------------------------------------------------------------+
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:491:0.

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

Let $K$ be an abstract simplicial complex on the vertex set $[n] =
\{1\dots,n\}$. We represent dimension $i$ faces of $K$ as lexicographically
ordered cardinality $i+1$ subsets $\{l_0 < \dots < l_i\}$ of $[n]$. We further
let $C_i$ be the free abelian group on the set of $i$-dimensional faces of $K$.

By these conventions the differential from the free abelian group of $K$'s
dimension $i$ faces to the free abelian group of $K$'s dimension $i-1$ faces
sends each $\{l_0 < \dots < l_i\}$ to the signed sum of all lexicographically
ordered sets $\{l_0 < \dots < l_i\} \backslash \{l_j\}$ as $j$ ranges from $0$
to $i$.

Here, the sign in front of  $\{l_0 < \dots < l_i\} \backslash \{l_j\}$ is
$(-1)^j$.

Using the constructors simplicialChainComplex,
and reducedSimplicialChainComplex,
respectively, 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                                                              |
+-----------------------------------------------------------------------------+
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:523:0.

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                                                                    |
+-----------------------------------------------------------------------------+
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:541:0.

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

  * Usage:
        inducedReducedSimplicialChainComplexMap(K,L)
  * Inputs:
      * K, an abstract simplicial complex,
      * L, an abstract simplicial complex,
  * Outputs:
      * a map of complexes (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,
    -- the 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).

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

The source of this document is in AbstractSimplicialComplexes.m2:822:0.

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

  * Usage:
        inducedSimplicialChainComplexMap(K,L)
  * Inputs:
      * K, an abstract simplicial complex,
      * L, an abstract simplicial complex,
  * Outputs:
      * a map of complexes (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
    -- the 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).

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

The source of this document is in AbstractSimplicialComplexes.m2:790:0.

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

See also
========

  * new (Macaulay2Doc) -- new objects and new types

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

  * new AbstractSimplicialComplex
-------------------------------------------------------------------------------

The source of this document is in AbstractSimplicialComplexes.m2:611:0.

randomAbstractSimplicialComplex -- create a random abstract simplicial complex
******************************************************************************

  * Usage:
        randomAbstractSimplicialComplex(n)
        randomAbstractSimplicialComplex(n,r)
        randomAbstractSimplicialComplex(n,m,d)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * r, an integer (Macaulay2Doc),
      * m, an integer (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Verify (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * an abstract simplicial complex,

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

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

+-----------------------------------------------------------------------------+
|i1 : K = randomAbstractSimplicialComplex(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}}                   |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
+-----------------------------------------------------------------------------+

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

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

Create the random complex $Y_d(n,m)$ which has vertex set $[n]$ and complete
$(d − 1)$-skeleton, and has $m$ $d$-dimensional faces, chosen at random from
all $\binom{\binom{n}{d+1}}{m}$ possibilities. Such random simplicial complexes
appear in lots of different contexts including in the article Cohen-Lenstra
heuristics for torsion in homology of random complexes (see
https://www.tandfonline.com/doi/abs/10.1080/10586458.2018.1473821 ) by  M.
Kahle, F. H. Lutz, A. Newman, and K. Parsons [Exp. Math. vol. 29, no. 3
(2020)]. By default, there is a chance that the output may have fewer than $m$
faces. To avoid this, set the Verify option to true.

+-----------------------------------------------------------------------------+
|i3 : N = randomAbstractSimplicialComplex(6,3,2)                              |
|                                                                             |
|o3 = AbstractSimplicialComplex{-1 => {{}}                                    |
|                               0 => {{1}, {2}, {3}, {4}, {5}, {6}}           |
|                               1 => {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, |
|                               2 => {{2, 3, 4}, {3, 5, 6}, {4, 5, 6}}        |
|                                                                             |
|o3 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|{2, 3}, {2, 4}, {2, 5}, {2, 6}, {3, 4}, {3, 5}, {3, 6}, {4, 5}, {4, 6}, {5,  |
|-----------------------------------------------------------------------------|
|   }                                                                         |
|                                                                             |
|6}}                                                                          |
+-----------------------------------------------------------------------------+
|i4 : tally apply(1000, i ->  #(randomAbstractSimplicialComplex(5,3,2))_2)    |
|                                                                             |
|o4 = Tally{1 => 13 }                                                         |
|           2 => 282                                                          |
|           3 => 705                                                          |
|                                                                             |
|o4 : Tally                                                                   |
+-----------------------------------------------------------------------------+
|i5 : tally apply(1000, i ->                                                  |
|                                                                             |
|o5 = Tally{3 => 1000}                                                        |
|                                                                             |
|o5 : Tally                                                                   |
|-----------------------------------------------------------------------------|
|#(randomAbstractSimplicialComplex(5,3,2,Verify=>true))_2)                    |
+-----------------------------------------------------------------------------+

See also
========

  * randomSubSimplicialComplex -- create a
    random subsimplicial complex
  * random (Macaulay2Doc) -- get a random object
  * RandomIdeals -- A package to construct various
    sorts of random ideals

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

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

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

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

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

The source of this document is in AbstractSimplicialComplexes.m2:687:0.

randomSubSimplicialComplex -- create a random subsimplicial complex
*******************************************************************

  * Usage:
        randomSubSimplicialComplex(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * an abstract simplicial complex,

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

Creates a random subsimplicial complex of a given simplicial complex.

+-----------------------------------------------------------------------------+
|i1 : K = randomAbstractSimplicialComplex(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}}                   |
|                                                                             |
|o1 : AbstractSimplicialComplex                                               |
|-----------------------------------------------------------------------------|
|       }                                                                     |
|                                                                             |
|{3, 4}}                                                                      |
+-----------------------------------------------------------------------------+
|i2 : J = randomSubSimplicialComplex(K)                                       |
|                                                                             |
|o2 = AbstractSimplicialComplex{-1 => {{}}                   }                |
|                               0 => {{1}, {2}, {3}}                          |
|                               1 => {{1, 2}, {1, 3}, {2, 3}}                 |
|                               2 => {{1, 2, 3}}                              |
|                                                                             |
|o2 : AbstractSimplicialComplex                                               |
+-----------------------------------------------------------------------------+

See also
========

  * randomAbstractSimplicialComplex, --
    create a random abstract simplicial complex

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

  * "randomSubSimplicialComplex(AbstractSimplicialComplex)"

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

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

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

The source of this document is in AbstractSimplicialComplexes.m2:711:0.

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

  * Usage:
        reducedSimplicialChainComplex(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * a complex (Complexes),

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).

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

The source of this document is in AbstractSimplicialComplexes.m2:844:0.

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

  * Usage:
        simplicialChainComplex(K)
  * Inputs:
      * K, an abstract simplicial complex,
  * Outputs:
      * a complex (Complexes),

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).

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

The source of this document is in AbstractSimplicialComplexes.m2:866:0.