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

ToricTopology -- homological computations in toric topology
***********************************************************

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

ToricTopology is a package for computing with quasitoric manifolds, small
covers and moment-angle complexes.

A quasitoric manifold (or small cover) is entirely determined by a pair
consisting of a simplicial complex K and a matrix lambda which is
characteristic for K.

If K has n vertices, we can think of its k-faces as sets of integers between 1
and n. A matrix lambda is characteristic for K if all maximal minors of lambda
indexed by the facets of  K have determinant equal to 1 or -1.

Authors
=======

  * Alvise Trevisan (see http://www.enpicom.com ) <a.trevisan@enpicom.com>
  * Alexander I. Suciu <a.suciu@neu.edu>
  * Kumar Sannidhya Shukla <kshukla5@uwo.ca>

Version
=======

This documentation describes version 1.2 of ToricTopology, released May 20,
2026.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{ToricTopologySource,                                                   |
|  title = {{ToricTopology: A \emph{Macaulay2} package. Version~1.2}},        |
|  author = {Alvise Trevisan and Alexander I. Suciu and Kumar Sannidhya Shukla|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|},                                                                           |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * MomentAngleComplex -- the class of all
        moment-angle complexes
      * QuasiToricManifold -- the class of all
        quasitoric manifolds
      * SmallCover -- the class of all small covers
  * Functions and commands
      * AFPVariety -- non-equivariantly formal toric
        varieties
      * bettiMAC -- (deprecated) compute the Betti numbers of
        a moment-angle complex
      * bettiQTM -- (deprecated) compute the Betti numbers of
        a quasitoric manifold
      * bettiSmallCover -- (deprecated) compute the
        betti numbers of a small cover
      * cohomologyRing -- compute the cohomology ring of
        a small cover or quasitoric manifold
      * complexProjectiveSpace -- complex
        projective space of dimension n
      * equivariantCohomology -- compute the
        equivariant cohomology of a toric space (normal toric variety and
        moment-angle complex)
      * eulerMAC -- (deprecated) compute the Euler
        characteristic of a moment-angle complex
      * hessenbergVariety -- Hessenberg variety
        associated to the n-permutahedron
      * isValidChar -- whether a matrix is characteristic
        for a simplicial complex
      * momentAngleComplex -- create a moment-angle
        complex
      * quasiToricManifold -- create a quasitoric
        manifold
      * realProjectiveSpace -- real projective
        space of dimension n
      * smallCover -- create a small cover
      * stiefelWhitney -- compute the Stiefel-Whitney
        classes of a small cover
  * Methods
      * "AFPVariety(ZZ,ZZ)" -- see AFPVariety, --
        non-equivariantly formal toric varieties
      * "betti(MomentAngleComplex)" -- see betti, -- compute the
        Betti numbers of a toric space
      * "betti(NormalToricVariety)" -- see betti, -- compute the
        Betti numbers of a toric space
      * "betti(QuasiToricManifold)" -- see betti, -- compute the
        Betti numbers of a toric space
      * "betti(SmallCover)" -- see betti, -- compute the Betti
        numbers of a toric space
      * "betti(ZZ,MomentAngleComplex)" -- see betti, -- compute
        the Betti numbers of a toric space
      * "betti(ZZ,NormalToricVariety)" -- see betti, -- compute
        the Betti numbers of a toric space
      * "betti(ZZ,QuasiToricManifold)" -- see betti, -- compute
        the Betti numbers of a toric space
      * "betti(ZZ,SmallCover)" -- see betti, -- compute the Betti
        numbers of a toric space
      * "bettiMAC(MomentAngleComplex)" -- see bettiMAC, --
        (deprecated) compute the Betti numbers of a moment-angle complex
      * "bettiMAC(ZZ,MomentAngleComplex)" -- see bettiMAC, --
        (deprecated) compute the Betti numbers of a moment-angle complex
      * "bettiQTM(QuasiToricManifold)" -- see bettiQTM, --
        (deprecated) compute the Betti numbers of a quasitoric manifold
      * "bettiQTM(ZZ,QuasiToricManifold)" -- see bettiQTM, --
        (deprecated) compute the Betti numbers of a quasitoric manifold
      * "bettiSmallCover(SmallCover)" -- see bettiSmallCover,
        -- (deprecated) compute the betti numbers of a small
        cover
      * "bettiSmallCover(ZZ,SmallCover)" -- see bettiSmallCover,
        -- (deprecated) compute the betti numbers of a small
        cover
      * "chern(QuasiToricManifold)" -- see chern, -- compute the
        Chern classes of a quasitoric manifold
      * "cohomologyRing(QuasiToricManifold)" -- see cohomologyRing,
        -- compute the cohomology ring of a small cover or
        quasitoric manifold
      * "cohomologyRing(SmallCover)" -- see cohomologyRing,
        -- compute the cohomology ring of a small cover or
        quasitoric manifold
      * "complexProjectiveSpace(ZZ)" -- see complexProjectiveSpace,
        -- complex projective space of dimension n
      * "equivariantCohomology(MomentAngleComplex)" -- see
        equivariantCohomology, -- compute the
        equivariant cohomology of a toric space (normal toric variety and
        moment-angle complex)
      * "equivariantCohomology(NormalToricVariety)" -- see
        equivariantCohomology, -- compute the
        equivariant cohomology of a toric space (normal toric variety and
        moment-angle complex)
      * "euler(MomentAngleComplex)" -- see euler, -- compute the
        Euler characteristic of a moment-angle complex
      * "eulerMAC(MomentAngleComplex)" -- see eulerMAC, --
        (deprecated) compute the Euler characteristic of a moment-angle complex
      * "hessenbergVariety(ZZ)" -- see hessenbergVariety,
        -- Hessenberg variety associated to the
        n-permutahedron
      * "realProjectiveSpace(ZZ)" -- see realProjectiveSpace,
        -- real projective space of dimension n
      * "stiefelWhitney(SmallCover)" -- see stiefelWhitney,
        -- compute the Stiefel-Whitney classes of a small cover
  * Symbols
      * MACSimplicialComplex (missing documentation)
      * QTMCharacteristicMatrix (missing documentation)
      * QTMDimension (missing documentation)
      * QTMSimplicialComplex (missing documentation)

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

The object ToricTopology, is a package (Macaulay2Doc),
defined in ToricTopology.m2, with auxiliary files in
ToricTopology/.

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

The source of this document is in ToricTopology/Documentation.m2:23:0.

AFPVariety -- non-equivariantly formal toric varieties
******************************************************

  * Usage:
        AFPVariety(d, ord)
  * Inputs:
      * d, an integer (Macaulay2Doc),
      * ord, an integer (Macaulay2Doc),
  * Outputs:
      * a normal toric variety (NormalToricVarieties),

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

Normal toric variety whose equivariant cohomology is not free but is
torsion-free (as described in https://doi.org/10.1090/S0002-9947-2014-06165-5).
These varieties are described by their complex dimension $d$, and the syzygy
order $ord$ of their equivariant cohomology. Note that we must have 1 < ord <
d. For ord = 0, the equivariant cohomology is not torsion-free and for ord = d,
the equivariant cohomology is free. So we don't handle those cases.  The
variety is obtained by removing two appropriately chosen fixed points from
$(\mathbb{CP}^1)^d$.

The AFPVarity(2, 1) is $(\mathbb{CP^1})^2 - \{([1:0], [1:0]), ([0:1],
[0:1])\}$.

+--------------------------+
|i1 : X = AFPVariety (2, 1)|
|                          |
|o1 = X                    |
|                          |
|o1 : NormalToricVariety   |
+--------------------------+
|i2 : betti X              |
|                          |
|o2 = {1, 0, 2, 1, 0}      |
|                          |
|o2 : List                 |
+--------------------------+

Ways to use AFPVariety:
=======================

  * "AFPVariety(ZZ,ZZ)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:644:0.

betti -- compute the Betti numbers of a toric space
***************************************************

  * Usage:
        betti(k,X)
        betti(X)
  * Inputs:
      * k, an integer (Macaulay2Doc), (optional)
      * X, a small cover,
      * X, a quasitoric manifold,
      * X, a moment-angle complex,
      * X, a normal toric variety (NormalToricVarieties),
  * Optional inputs (Macaulay2Doc),:
      * Minimize (missing documentation) => ..., default value false,
      * Weights (Macaulay2Doc), => ..., default
        value null,
  * Outputs:
      * an integer (Macaulay2Doc), the k-th Betti number of the
        moment angle complex (if k is provided)
      * a list (Macaulay2Doc), of all Betti numbers

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

This method computes the Betti numbers of a toric space (a space with a torus
action, ie, small cover, quasitoric manifold, moment-angle complex and normal
toric variety).  For small-covers, the formula of Suciu-Trevisan
(https://arxiv.org/abs/1302.2342) is used.  For quasitoric manifolds, the
classical formula of Davis-Januszkiewicz
(http://dx.doi.org/10.1215/S0012-7094-91-06217-4) is used. For moment-angle
complexes, the theorem of Baskakov-Buchstaber-Panov
(https://arxiv.org/abs/math/0407189) is used. For normal toric varieties, the
result of Franz (https://arxiv.org/abs/math/0308253) is used. If a dimension k
is specified, then only the k-th Betti number of X is computed. If no dimension
is specified, all the Betti numbers between 0 and 2m are computed (where m is
either the dimension of the small-cover, quasitoric manifold or normal toric
variety X, or it is the number of vertices in the underlying simplicial complex
of the moment-angle complex).

The small cover over a square with the characteristic matrix $\begin{pmatrix}1
& 1 & 0 & 1 \\ 0 & 1 & 1 & 1\end{pmatrix}$ is the Klein bottle, as indicated by
its betti numbers.

+--------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                   |
|                                                                          |
|o1 = SimplicialComplexes                                                  |
|                                                                          |
|o1 : Package                                                              |
+--------------------------------------------------------------------------+
|i2 : R = QQ[a..d]                                                         |
|                                                                          |
|o2 = R                                                                    |
|                                                                          |
|o2 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i3 : K = simplicialComplex {a*b, b*c, c*d, d*a}                           |
|                                                                          |
|o3 = simplicialComplex | cd ad bc ab |                                    |
|                                                                          |
|o3 : SimplicialComplex                                                    |
+--------------------------------------------------------------------------+
|i4 : lambda = matrix{{1, 1, 0, 1}, {0, 1, 1, 1}}                          |
|                                                                          |
|o4 = | 1 1 0 1 |                                                          |
|     | 0 1 1 1 |                                                          |
|                                                                          |
|              2       4                                                   |
|o4 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i5 : X = smallCover(K, lambda)                                            |
|                                                                          |
|o5 = SmallCover{QTMCharacteristicMatrix => | 1 1 0 1 |                   }|
|                                           | 0 1 1 1 |                    |
|                QTMDimension => 2                                         |
|                QTMSimplicialComplex => simplicialComplex | cd ad bc ab | |
|                                                                          |
|o5 : SmallCover                                                           |
+--------------------------------------------------------------------------+
|i6 : betti X                                                              |
|                                                                          |
|o6 = {1, 1, 0}                                                            |
|                                                                          |
|o6 : List                                                                 |
+--------------------------------------------------------------------------+

The quasitoric manifold over a triangle with the characteristic matrix
$\begin{pmatrix}1 & 0 & -1 \\ 0 & 1 & -1\end{pmatrix}$ is the complex
projective plane $\mathbb{CP}^2$, as indicated by its betti numbers.

+-----------------------------------------------------------------------------+
|i7 : needsPackage "SimplicialComplexes"                                      |
|                                                                             |
|o7 = SimplicialComplexes                                                     |
|                                                                             |
|o7 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i8 : R = QQ[a..c]                                                            |
|                                                                             |
|o8 = R                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : K = simplicialComplex {a*b, b*c, c*a}                                   |
|                                                                             |
|o9 = simplicialComplex | bc ac ab |                                          |
|                                                                             |
|o9 : SimplicialComplex                                                       |
+-----------------------------------------------------------------------------+
|i10 : lambda = matrix{{1, 0, -1}, {0, 1, -1}}                                |
|                                                                             |
|o10 = | 1 0 -1 |                                                             |
|      | 0 1 -1 |                                                             |
|                                                                             |
|               2       3                                                     |
|o10 : Matrix ZZ  <-- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i11 : X = quasiToricManifold(K, lambda)                                      |
|                                                                             |
|o11 = QuasiToricManifold{QTMCharacteristicMatrix => | 1 0 -1 |               |
|                                                    | 0 1 -1 |               |
|                         QTMDimension => 4                                   |
|                         QTMSimplicialComplex => simplicialComplex | bc ac ab|
|                                                                             |
|o11 : QuasiToricManifold                                                     |
|-----------------------------------------------------------------------------|
| }                                                                           |
|                                                                             |
|                                                                             |
||                                                                            |
+-----------------------------------------------------------------------------+
|i12 : betti X                                                                |
|                                                                             |
|o12 = {1, 0, 1, 0, 1}                                                        |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

The moment-angle complex corresponding to the simplicial complex consisting of
two disjoint vertices is homeomorphic to $S^3$, the 3-sphere as indicated by
its Betti numbers.

+---------------------------------------------------------------------------+
|i13 : needsPackage "SimplicialComplexes"                                   |
|                                                                           |
|o13 = SimplicialComplexes                                                  |
|                                                                           |
|o13 : Package                                                              |
+---------------------------------------------------------------------------+
|i14 : R = QQ[x,y]                                                          |
|                                                                           |
|o14 = R                                                                    |
|                                                                           |
|o14 : PolynomialRing                                                       |
+---------------------------------------------------------------------------+
|i15 : K = simplicialComplex {x, y}                                         |
|                                                                           |
|o15 = simplicialComplex | y x |                                            |
|                                                                           |
|o15 : SimplicialComplex                                                    |
+---------------------------------------------------------------------------+
|i16 : Z = momentAngleComplex K                                             |
|                                                                           |
|o16 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | y x |}|
|                                                                           |
|o16 : MomentAngleComplex                                                   |
+---------------------------------------------------------------------------+
|i17 : betti Z                                                              |
|                                                                           |
|o17 = {1, 0, 0, 1, 0}                                                      |
|                                                                           |
|o17 : List                                                                 |
+---------------------------------------------------------------------------+

Let $\mathcal{Z}_K$ be the moment-angle corresponding to the simplicial complex
consisting on 3 vertices, with an edge and a disjoint vertex. By Hochster's
formula, its third cohomology $H^3(\mathcal{Z}_K)$ will have rank $2$. We can
verify this as follows,

+----------------------------------------------------------------------------+
|i18 : needsPackage "SimplicialComplexes"                                    |
|                                                                            |
|o18 = SimplicialComplexes                                                   |
|                                                                            |
|o18 : Package                                                               |
+----------------------------------------------------------------------------+
|i19 : R = QQ[x..z]                                                          |
|                                                                            |
|o19 = R                                                                     |
|                                                                            |
|o19 : PolynomialRing                                                        |
+----------------------------------------------------------------------------+
|i20 : K = simplicialComplex {x, y*z}                                        |
|                                                                            |
|o20 = simplicialComplex | x yz |                                            |
|                                                                            |
|o20 : SimplicialComplex                                                     |
+----------------------------------------------------------------------------+
|i21 : Z = momentAngleComplex K                                              |
|                                                                            |
|o21 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | x yz |}|
|                                                                            |
|o21 : MomentAngleComplex                                                    |
+----------------------------------------------------------------------------+
|i22 : betti (3, Z)                                                          |
|                                                                            |
|o22 = 2                                                                     |
+----------------------------------------------------------------------------+

The moment-angle corresponding to the boundary $\partial \Delta^2$ of the
2-simplex is homeomorphic to $S^5$, as reflected by its Betti numbers.

+-----------------------------------------------------------------------------+
|i23 : needsPackage "SimplicialComplexes"                                     |
|                                                                             |
|o23 = SimplicialComplexes                                                    |
|                                                                             |
|o23 : Package                                                                |
+-----------------------------------------------------------------------------+
|i24 : R = QQ[x..z]                                                           |
|                                                                             |
|o24 = R                                                                      |
|                                                                             |
|o24 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i25 : K = simplicialComplex {x*y, y*z, x*z}                                  |
|                                                                             |
|o25 = simplicialComplex | yz xz xy |                                         |
|                                                                             |
|o25 : SimplicialComplex                                                      |
+-----------------------------------------------------------------------------+
|i26 : Z = momentAngleComplex K                                               |
|                                                                             |
|o26 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | yz xz xy|
|                                                                             |
|o26 : MomentAngleComplex                                                     |
|-----------------------------------------------------------------------------|
||}                                                                           |
+-----------------------------------------------------------------------------+
|i27 : betti Z                                                                |
|                                                                             |
|o27 = {1, 0, 0, 0, 0, 1, 0}                                                  |
|                                                                             |
|o27 : List                                                                   |
+-----------------------------------------------------------------------------+

The consider the normal toric variety $\mathbb{CP}^1 \times \mathbb{CP}^1$ with
two fixed points $([1:0], [1:0])$ and $([0:1], [0:1])$ removed. Its betti
numbers can be computed as follows:

+-----------------------------------------------------------------------------+
|i28 : needsPackage "NormalToricVarieties"                                    |
|                                                                             |
|o28 = NormalToricVarieties                                                   |
|                                                                             |
|o28 : Package                                                                |
+-----------------------------------------------------------------------------+
|i29 : rayList = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}                           |
|                                                                             |
|o29 = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}                                     |
|                                                                             |
|o29 : List                                                                   |
+-----------------------------------------------------------------------------+
|i30 : coneList = {{1, 2}, {0, 3}}                                            |
|                                                                             |
|o30 = {{1, 2}, {0, 3}}                                                       |
|                                                                             |
|o30 : List                                                                   |
+-----------------------------------------------------------------------------+
|i31 : X = normalToricVariety (rayList, coneList)                             |
|                                                                             |
|o31 = X                                                                      |
|                                                                             |
|o31 : NormalToricVariety                                                     |
+-----------------------------------------------------------------------------+
|i32 : betti X                                                                |
|warning: clearing value of symbol c to allow access to subscripted           |
|       : debug with expression   debug 8545   or with command line           |
|                                                                             |
|o32 = {1, 0, 2, 1, 0}                                                        |
|                                                                             |
|o32 : List                                                                   |
|-----------------------------------------------------------------------------|
|variables based on it                                                        |
|option   --debug 8545                                                        |
+-----------------------------------------------------------------------------+

Ways to use betti:
==================

  * "betti(GroebnerBasis)" -- see betti (Macaulay2Doc), -- display
    or modify a Betti diagram
  * "betti(Ideal)" -- see betti (Macaulay2Doc), -- display or
    modify a Betti diagram
  * "betti(Matrix)" -- see betti (Macaulay2Doc), -- display or
    modify a Betti diagram
  * "betti(Module)" -- see betti (Macaulay2Doc), -- display or
    modify a Betti diagram
  * "betti(MomentAngleComplex)"
  * "betti(NormalToricVariety)"
  * "betti(QuasiToricManifold)"
  * "betti(SmallCover)"
  * "betti(ZZ,MomentAngleComplex)"
  * "betti(ZZ,NormalToricVariety)"
  * "betti(ZZ,QuasiToricManifold)"
  * "betti(ZZ,SmallCover)"
  * betti(BettiTally) (Macaulay2Doc) -- view and
    set the weight vector of a Betti diagram
  * betti(CoherentSheaf) (missing documentation)
  * betti(Complex) (Complexes) -- display of degrees
    in a complex

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

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

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

The source of this document is in ToricTopology/Documentation.m2:474:0.

bettiMAC -- (deprecated) compute the Betti numbers of a moment-angle complex
****************************************************************************

  * Usage:
        bettiMAC(k,Z)
        bettiMAC(Z)
  * Inputs:
      * k, an integer (Macaulay2Doc), (optional)
      * Z, a moment-angle complex,
  * Outputs:
      * an integer (Macaulay2Doc), the k-th Betti number of the
        moment angle complex (if k is provided)
      * a list (Macaulay2Doc), of all Betti numbers

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

This method computes the Betti numbers of a moment-angle complex using the
theorem of Baskakov-Buchstaber-Panov. If a dimension k is specified, then only
the k-th Betti number of Z is computed. If no dimension is specified, all the
Betti numbers between 0 and 2m are computed (where m is the number of vertices
in the underlying simplicial complex).

Ways to use bettiMAC:
=====================

  * "bettiMAC(MomentAngleComplex)"
  * "bettiMAC(ZZ,MomentAngleComplex)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:503:0.

bettiQTM -- (deprecated) compute the Betti numbers of a quasitoric manifold
***************************************************************************

  * Usage:
        bettiQTM(k,M)
        bettiQTM(M)
  * Inputs:
      * k, an integer (Macaulay2Doc),
      * M, a quasitoric manifold,
  * Outputs:
      * an integer (Macaulay2Doc),
      * a list (Macaulay2Doc),

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

Compute the Betti numbers of a quasitoric manifold.  If a dimension k is
specified, then only the k-th Betti number of M is computed.  If no dimension
is specified, all the Betti numbers between 0 and the dimension of M are
computed.

Ways to use bettiQTM:
=====================

  * "bettiQTM(QuasiToricManifold)"
  * "bettiQTM(ZZ,QuasiToricManifold)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:361:0.

bettiSmallCover -- (deprecated) compute the betti numbers of a small cover
**************************************************************************

  * Usage:
        bettiSmallCover(k,N)
        bettiSmallCover(N)
  * Inputs:
      * k, an integer (Macaulay2Doc),
      * N, a small cover,
  * Outputs:
      * an integer (Macaulay2Doc),
      * a list (Macaulay2Doc),

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

Compute the rational Betti numbers of a small cover.  If a dimension k is
specified, then only the k-th Betti number of N is computed.  If no dimension
is specified, all the Betti numbers between 0 and the dimension of N are
computed.

Ways to use bettiSmallCover:
============================

  * "bettiSmallCover(SmallCover)"
  * "bettiSmallCover(ZZ,SmallCover)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:336:0.

chern -- compute the Chern classes of a quasitoric manifold
***********************************************************

  * Usage:
        chern(M)
  * Inputs:
      * M, a quasitoric manifold,
  * Outputs:
      * a list (Macaulay2Doc),

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

Compute the Chern classes of a quasitoric manifold. The output is a list of
elements in the cohomology ring of M.

+-----------------------------------------------------------------------------+
|i1 : X = complexProjectiveSpace 3                                            |
|                                                                             |
|o1 = QuasiToricManifold{QTMCharacteristicMatrix => | 1 0 0 -1 |              |
|                                                   | 0 1 0 -1 |              |
|                                                   | 0 0 1 -1 |              |
|                        QTMDimension => 6                                    |
|                        QTMSimplicialComplex => simplicialComplex | bcd acd  |
|                                                                             |
|o1 : QuasiToricManifold                                                      |
|-----------------------------------------------------------------------------|
|         }                                                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|abd abc |                                                                    |
+-----------------------------------------------------------------------------+
|i2 : chern X                                                                 |
|                                                                             |
|               2    3                                                        |
|o2 = {1, 4d, 6d , 4d }                                                       |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * cohomologyRing -- compute the cohomology ring of a
    small cover or quasitoric manifold

Ways to use chern:
==================

  * "chern(QuasiToricManifold)"
  * chern(AbstractSheaf) (Schubert2) -- compute
    the total Chern class of a sheaf
  * chern(ZZ,AbstractSheaf) (Schubert2), --
    compute a Chern class of a sheaf
  * chern(ZZ,ChernClassVariableTable) (Schubert2)
    -- get value of a Chern
    class variable
  * "chern(CoherentSheaf)" -- see chern(ZZ,CoherentSheaf) (NormalToricVarieties),
    -- compute the Chern
    class of a coherent sheaf
  * chern(ZZ,CoherentSheaf) (NormalToricVarieties)
    -- compute the Chern
    class of a coherent sheaf
  * chern(ZZ,Symbol) (Schubert2) -- make a Chern
    class symbol
  * chern(ZZ,ZZ,AbstractSheaf) (Schubert2)
    -- compute several Chern
    classes of an abstract sheaf
  * chern(ZZ,ZZ,CoherentSheaf) (missing documentation)

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

The object chern (Schubert2), is a method function (Macaulay2Doc).

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

The source of this document is in ToricTopology/Documentation.m2:310:0.

cohomologyRing -- compute the cohomology ring of a small cover or quasitoric manifold
*************************************************************************************

  * Usage:
        cohomologyRing(N)
        cohomologyRing(M)
  * Inputs:
      * N, a small cover,
      * M, a quasitoric manifold,
  * Outputs:
      * a quotient ring (Macaulay2Doc),

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

Compute the cohomology ring of a small cover (over ZZ/2) or quasitoric manifold
(over ZZ).

Ways to use cohomologyRing:
===========================

  * "cohomologyRing(QuasiToricManifold)"
  * "cohomologyRing(SmallCover)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:263:0.

complexProjectiveSpace -- complex projective space of dimension n
*****************************************************************

  * Usage:
        complexProjectiveSpace(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a quasitoric manifold,

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

Complex projective space of dimension n, as a quasitoric manifold.

See also
========

  * realProjectiveSpace -- real projective space of
    dimension n

Ways to use complexProjectiveSpace:
===================================

  * "complexProjectiveSpace(ZZ)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:591:0.

equivariantCohomology -- compute the equivariant cohomology of a toric space (normal toric variety and moment-angle complex)
****************************************************************************************************************************

  * Usage:
        equivariantCohomology(X)
        equivariantCohomology(Z)
  * Inputs:
      * X, a normal toric variety (NormalToricVarieties),
      * Z, a moment-angle complex,
  * Outputs:
      * a module (Macaulay2Doc), the torus equivariant cohomology
        of Z, as a module over polynomial ring

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

Compute the equivariant cohomology of certain classes of spaces with torus
actions: normal toric varieties and  moment-angle complex. The equivariant
cohomology is computed as a module over polynomial ring in which the
coefficients are dependent on the context. For normal toric varieties, the
underlying ring is the polynomial ring QQ[t_1, .. t_r] where r is the dimension
of the toric variety. For moment-angle complexes, the underlying ring is the
polynomial ring k[x_1, ..., x_m] where k is the coefficient ring of the
polynomial ring over which the underlying simplicial complex was created.

The equivariant cohomology of a moment-angle complex is free over the
polynomial ring when the simplicial complex is a full simplex.

+--------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                   |
|                                                                          |
|o1 = SimplicialComplexes                                                  |
|                                                                          |
|o1 : Package                                                              |
+--------------------------------------------------------------------------+
|i2 : R = QQ[x,y,z]                                                        |
|                                                                          |
|o2 = R                                                                    |
|                                                                          |
|o2 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i3 : K = simplicialComplex {x*y*z}                                        |
|                                                                          |
|o3 = simplicialComplex | xyz |                                            |
|                                                                          |
|o3 : SimplicialComplex                                                    |
+--------------------------------------------------------------------------+
|i4 : Z = momentAngleComplex K                                             |
|                                                                          |
|o4 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | xyz |}|
|                                                                          |
|o4 : MomentAngleComplex                                                   |
+--------------------------------------------------------------------------+
|i5 : M = equivariantCohomology Z                                          |
|                                                                          |
|               1                                                          |
|o5 = (QQ[x..z])                                                           |
|                                                                          |
|o5 : QQ[x..z]-module, free                                                |
+--------------------------------------------------------------------------+
|i6 : isFreeModule M                                                       |
|                                                                          |
|o6 = true                                                                 |
+--------------------------------------------------------------------------+

If there is any missing simplex, then the equivariant cohomology is not free.

+-----------------------------------------------------------------------------+
|i7 : needsPackage "SimplicialComplexes"                                      |
|                                                                             |
|o7 = SimplicialComplexes                                                     |
|                                                                             |
|o7 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i8 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o8 = R                                                                       |
|                                                                             |
|o8 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i9 : K = simplicialComplex {x*y, y*z, x*z}                                   |
|                                                                             |
|o9 = simplicialComplex | yz xz xy |                                          |
|                                                                             |
|o9 : SimplicialComplex                                                       |
+-----------------------------------------------------------------------------+
|i10 : Z = momentAngleComplex K                                               |
|                                                                             |
|o10 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | yz xz xy|
|                                                                             |
|o10 : MomentAngleComplex                                                     |
|-----------------------------------------------------------------------------|
||}                                                                           |
+-----------------------------------------------------------------------------+
|i11 : M = equivariantCohomology Z                                            |
|                                                                             |
|o11 = cokernel | xyz |                                                       |
|                                                                             |
|                                             1                               |
|o11 : QQ[x..z]-module, quotient of (QQ[x..z])                                |
+-----------------------------------------------------------------------------+
|i12 : isFreeModule M                                                         |
|                                                                             |
|o12 = false                                                                  |
+-----------------------------------------------------------------------------+

We can also compute the equivariant cohomology of a normal toric variety. In
the example below, we compute the equivariant cohomology of $\mathbb{CP}^2$
with respect to the standard torus ($T^2$) action.

+-----------------------------------------+
|i13 : needsPackage "NormalToricVarieties"|
|                                         |
|o13 = NormalToricVarieties               |
|                                         |
|o13 : Package                            |
+-----------------------------------------+
|i14 : rayList = {{1, 0}, {0, 1}, {}}     |
|                                         |
|o14 = {{1, 0}, {0, 1}, {}}               |
|                                         |
|o14 : List                               |
+-----------------------------------------+

Ways to use equivariantCohomology:
==================================

  * "equivariantCohomology(MomentAngleComplex)"
  * "equivariantCohomology(NormalToricVariety)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:240:0.

euler -- compute the Euler characteristic of a moment-angle complex
*******************************************************************

  * Usage:
        euler(Z)
  * Inputs:
      * Z, a moment-angle complex,
  * Outputs:
      * an integer (Macaulay2Doc), the Euler characteristic of the
        moment-angle complex

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

This method computes the Euler characteristic of moment-angle complexes.

The Euler characteristic of a moment-angle complex is $0$ if the underlying
simplicial complex is not a full simplex.

+-----------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                      |
|                                                                             |
|o1 = SimplicialComplexes                                                     |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R = QQ[a..d]                                                            |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : K0 = simplicialComplex {a*b, b*c, c*d, d*a}                             |
|                                                                             |
|o3 = simplicialComplex | cd ad bc ab |                                       |
|                                                                             |
|o3 : SimplicialComplex                                                       |
+-----------------------------------------------------------------------------+
|i4 : Z0 = momentAngleComplex K0                                              |
|                                                                             |
|o4 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | cd ad bc |
|                                                                             |
|o4 : MomentAngleComplex                                                      |
|-----------------------------------------------------------------------------|
|ab |}                                                                        |
+-----------------------------------------------------------------------------+
|i5 : euler Z0                                                                |
|                                                                             |
|o5 = 0                                                                       |
+-----------------------------------------------------------------------------+
|i6 : K1 = simplicialComplex {a*b*c*d}                                        |
|                                                                             |
|o6 = simplicialComplex | abcd |                                              |
|                                                                             |
|o6 : SimplicialComplex                                                       |
+-----------------------------------------------------------------------------+
|i7 : Z1 = momentAngleComplex K1                                              |
|                                                                             |
|o7 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | abcd |}  |
|                                                                             |
|o7 : MomentAngleComplex                                                      |
+-----------------------------------------------------------------------------+
|i8 : euler Z1                                                                |
|                                                                             |
|o8 = 1                                                                       |
+-----------------------------------------------------------------------------+

Ways to use euler:
==================

  * "euler(MomentAngleComplex)"
  * euler(AbstractVariety) (Schubert2)
  * euler(CoherentSheaf) (Varieties) -- Euler
    characteristic of coherent sheaf
  * euler(Complex) (missing documentation)
  * euler(Ideal) (Varieties)
  * euler(Module) (Varieties)
  * euler(NormalToricVariety) (missing documentation)
  * euler(ProjectiveHilbertPolynomial) (Macaulay2Doc)
    -- constant term of
    the Hilbert polynomial
  * euler(ProjectiveVariety) (Varieties), --
    topological Euler characteristic of a (smooth) projective variety
  * euler(Ring) (Varieties)

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

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

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

The source of this document is in ToricTopology/Documentation.m2:534:0.

eulerMAC -- (deprecated) compute the Euler characteristic of a moment-angle complex
***********************************************************************************

  * Usage:
        eulerMAC(Z)
  * Inputs:
      * Z, a moment-angle complex,
  * Outputs:
      * an integer (Macaulay2Doc), the Euler characteristic of the
        moment-angle complex

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

This method computes the Euler characteristic of moment-angle complexes.

Ways to use eulerMAC:
=====================

  * "eulerMAC(MomentAngleComplex)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:553:0.

hessenbergVariety -- Hessenberg variety associated to the n-permutahedron
*************************************************************************

  * Usage:
        hessenbergVariety(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a small cover,

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

Hessenberg variety associated to the n-permutahedron, as small cover.

Ways to use hessenbergVariety:
==============================

  * "hessenbergVariety(ZZ)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:610:0.

isValidChar -- whether a matrix is characteristic for a simplicial complex
**************************************************************************

  * Usage:
        isValidChar(K,lambda)
  * Inputs:
      * K, an abstract simplicial complex (SimplicialComplexes),
      * lambda, a matrix (Macaulay2Doc),
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Checks whether lambda is characteristic for K.

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

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

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

The source of this document is in ToricTopology/Documentation.m2:94:0.

MACSimplicialComplex
********************

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

The object MACSimplicialComplex (missing documentation) is a symbol (Macaulay2Doc).

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

The source of this document is in currentString:1:379.

MomentAngleComplex -- the class of all moment-angle complexes
*************************************************************

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

Given a simplicial complex $K$ on $m$ vertices, the moment-angle complex
$\mathcal{Z}_K$ is a cellular complex constructed as a union of certain
products of disks and circles: $$\mathcal{Z_K} = \bigcup_{\sigma \in K} \left(
(D^2)^\sigma \times (S^1)^{[m] \setminus \sigma} \right).$$ These spaces admit
a natural action of the torus $T^m = (S^1)^m$. Non-singular toric varieties
(not necessarily complete) are homotopy equivalent to partial quotients of
moment-angle complexes by freely acting subtori of $T^m$. Thus, moment-angle
complexes are an important class of spaces studied in Toric Topology. Their
topological properties can be determined from the combinatorics of the
underlying simplicial complex.  This package implements methods to determine
some of these properties. A moment-angle complex is a special case of
polyhedral products.

See also
========

  * QuasiToricManifold -- the class of all
    quasitoric manifolds
  * SmallCover -- the class of all small covers

Functions and methods returning a moment-angle complex:
=======================================================

  * momentAngleComplex -- create a moment-angle
    complex

Methods that use a moment-angle complex:
========================================

  * "betti(MomentAngleComplex)" -- see betti, -- compute the Betti
    numbers of a toric space
  * "betti(ZZ,MomentAngleComplex)" -- see betti, -- compute the
    Betti numbers of a toric space
  * "bettiMAC(MomentAngleComplex)" -- see bettiMAC, --
    (deprecated) compute the Betti numbers of a moment-angle complex
  * "bettiMAC(ZZ,MomentAngleComplex)" -- see bettiMAC, --
    (deprecated) compute the Betti numbers of a moment-angle complex
  * "equivariantCohomology(MomentAngleComplex)" -- see
    equivariantCohomology, -- compute the equivariant
    cohomology of a toric space (normal toric variety and moment-angle complex)
  * "euler(MomentAngleComplex)" -- see euler, -- compute the Euler
    characteristic of a moment-angle complex
  * "eulerMAC(MomentAngleComplex)" -- see eulerMAC, --
    (deprecated) compute the Euler characteristic of a moment-angle complex

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

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

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

The source of this document is in ToricTopology/Documentation.m2:75:0.

momentAngleComplex -- create a moment-angle complex
***************************************************

  * Usage:
        momentAngleComplex(K)
  * Inputs:
      * K, an abstract simplicial complex (SimplicialComplexes),
  * Outputs:
      * a moment-angle complex,

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

Create a moment-angle complex with simplicial complex K.

This example creates a moment-angle complex over the simplicial complex
consisting of two disjoint vertices.

+--------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                   |
|                                                                          |
|o1 = SimplicialComplexes                                                  |
|                                                                          |
|o1 : Package                                                              |
+--------------------------------------------------------------------------+
|i2 : R = QQ[x,y]                                                          |
|                                                                          |
|o2 = R                                                                    |
|                                                                          |
|o2 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i3 : K = simplicialComplex {x, y}                                         |
|                                                                          |
|o3 = simplicialComplex | y x |                                            |
|                                                                          |
|o3 : SimplicialComplex                                                    |
+--------------------------------------------------------------------------+
|i4 : Z = momentAngleComplex K                                             |
|                                                                          |
|o4 = MomentAngleComplex{MACSimplicialComplex => simplicialComplex | y x |}|
|                                                                          |
|o4 : MomentAngleComplex                                                   |
+--------------------------------------------------------------------------+

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

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

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

The source of this document is in ToricTopology/Documentation.m2:181:0.

QTMCharacteristicMatrix
***********************

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

The object QTMCharacteristicMatrix (missing documentation) is a symbol (Macaulay2Doc).

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

The source of this document is in currentString:1:379.

QTMDimension
************

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

The object QTMDimension (missing documentation) is a symbol (Macaulay2Doc).

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

The source of this document is in currentString:1:379.

QTMSimplicialComplex
********************

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

The object QTMSimplicialComplex (missing documentation) is a symbol (Macaulay2Doc).

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

The source of this document is in currentString:1:379.

QuasiToricManifold -- the class of all quasitoric manifolds
***********************************************************

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

A quasitoric manifold is represented by a simplicial complex K and matrix which
is characteristic for K.

See also
========

  * SmallCover -- the class of all small covers

Functions and methods returning a quasitoric manifold:
======================================================

  * complexProjectiveSpace -- complex projective
    space of dimension n
  * "complexProjectiveSpace(ZZ)" -- see complexProjectiveSpace,
    -- complex projective space of dimension n
  * quasiToricManifold -- create a quasitoric
    manifold

Methods that use a quasitoric manifold:
=======================================

  * "betti(QuasiToricManifold)" -- see betti, -- compute the Betti
    numbers of a toric space
  * "betti(ZZ,QuasiToricManifold)" -- see betti, -- compute the
    Betti numbers of a toric space
  * "bettiQTM(QuasiToricManifold)" -- see bettiQTM, --
    (deprecated) compute the Betti numbers of a quasitoric manifold
  * "bettiQTM(ZZ,QuasiToricManifold)" -- see bettiQTM, --
    (deprecated) compute the Betti numbers of a quasitoric manifold
  * "chern(QuasiToricManifold)" -- see chern, -- compute the Chern
    classes of a quasitoric manifold
  * "cohomologyRing(QuasiToricManifold)" -- see cohomologyRing,
    -- compute the cohomology ring of a small cover or
    quasitoric manifold

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

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

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

The source of this document is in ToricTopology/Documentation.m2:49:0.

quasiToricManifold -- create a quasitoric manifold
**************************************************

  * Usage:
        quasiToricManifold(K,lambda)
  * Inputs:
      * K, an abstract simplicial complex (SimplicialComplexes),
      * lambda, a matrix (Macaulay2Doc),
  * Outputs:
      * a quasitoric manifold,

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

Create a quasitoric manifold over K with characteristic matrix lambda.  If
lambda is not characteristic for K, an error is returned.

The following example creates the 2-dimensional complex projective space as a
quasitoric manifold.

+-----------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                      |
|                                                                             |
|o1 = SimplicialComplexes                                                     |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R = QQ[a..c]                                                            |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : K = simplicialComplex {a*b, b*c, c*a}                                   |
|                                                                             |
|o3 = simplicialComplex | bc ac ab |                                          |
|                                                                             |
|o3 : SimplicialComplex                                                       |
+-----------------------------------------------------------------------------+
|i4 : lambda = matrix{{1, 0, -1}, {0, 1, -1}}                                 |
|                                                                             |
|o4 = | 1 0 -1 |                                                              |
|     | 0 1 -1 |                                                              |
|                                                                             |
|              2       3                                                      |
|o4 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i5 : X = quasiToricManifold(K, lambda)                                       |
|                                                                             |
|o5 = QuasiToricManifold{QTMCharacteristicMatrix => | 1 0 -1 |                |
|                                                   | 0 1 -1 |                |
|                        QTMDimension => 4                                    |
|                        QTMSimplicialComplex => simplicialComplex | bc ac ab |
|                                                                             |
|o5 : QuasiToricManifold                                                      |
|-----------------------------------------------------------------------------|
| }                                                                           |
|                                                                             |
|                                                                             |
||                                                                            |
+-----------------------------------------------------------------------------+

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

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

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

The source of this document is in ToricTopology/Documentation.m2:155:0.

realProjectiveSpace -- real projective space of dimension n
***********************************************************

  * Usage:
        realProjectiveSpace(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a small cover,

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

Real projective space of dimension n, as a small cover.

See also
========

  * complexProjectiveSpace -- complex projective
    space of dimension n

Ways to use realProjectiveSpace:
================================

  * "realProjectiveSpace(ZZ)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:572:0.

SmallCover -- the class of all small covers
*******************************************

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

A small cover is represented by a simplicial complex K and matrix which is
characteristic for K.

See also
========

  * QuasiToricManifold -- the class of all
    quasitoric manifolds

Functions and methods returning a small cover:
==============================================

  * hessenbergVariety -- Hessenberg variety
    associated to the n-permutahedron
  * "hessenbergVariety(ZZ)" -- see hessenbergVariety,
    -- Hessenberg variety associated to the n-permutahedron
  * realProjectiveSpace -- real projective space of
    dimension n
  * "realProjectiveSpace(ZZ)" -- see realProjectiveSpace,
    -- real projective space of dimension n
  * smallCover -- create a small cover

Methods that use a small cover:
===============================

  * "betti(SmallCover)" -- see betti, -- compute the Betti numbers
    of a toric space
  * "betti(ZZ,SmallCover)" -- see betti, -- compute the Betti
    numbers of a toric space
  * "bettiSmallCover(SmallCover)" -- see bettiSmallCover,
    -- (deprecated) compute the betti numbers of a small cover
  * "bettiSmallCover(ZZ,SmallCover)" -- see bettiSmallCover,
    -- (deprecated) compute the betti numbers of a small cover
  * "cohomologyRing(SmallCover)" -- see cohomologyRing,
    -- compute the cohomology ring of a small cover or quasitoric manifold
  * "stiefelWhitney(SmallCover)" -- see stiefelWhitney,
    -- compute the Stiefel-Whitney classes of a small cover

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

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

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

The source of this document is in ToricTopology/Documentation.m2:36:0.

smallCover -- create a small cover
**********************************

  * Usage:
        smallCover(K,lambda)
  * Inputs:
      * K, an abstract simplicial complex (SimplicialComplexes),
      * lambda, a matrix (Macaulay2Doc),
  * Outputs:
      * a small cover,

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

Create a small cover over K with characteristic matrix lambda.  If lambda is
not characteristic for K, then an error is returned.  The entries of lambda are
automatically converted to ZZ/2 entries, if they not already so.

The following example illustrates creating the 2-torus as a small cover over
the unit square.

+--------------------------------------------------------------------------+
|i1 : needsPackage "SimplicialComplexes"                                   |
|                                                                          |
|o1 = SimplicialComplexes                                                  |
|                                                                          |
|o1 : Package                                                              |
+--------------------------------------------------------------------------+
|i2 : R = QQ[a..d]                                                         |
|                                                                          |
|o2 = R                                                                    |
|                                                                          |
|o2 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i3 : K = simplicialComplex {a*b, b*c, c*d, d*a}                           |
|                                                                          |
|o3 = simplicialComplex | cd ad bc ab |                                    |
|                                                                          |
|o3 : SimplicialComplex                                                    |
+--------------------------------------------------------------------------+
|i4 : lambda = matrix{{1, 0, 1, 0}, {0, 1, 0, 1}}                          |
|                                                                          |
|o4 = | 1 0 1 0 |                                                          |
|     | 0 1 0 1 |                                                          |
|                                                                          |
|              2       4                                                   |
|o4 : Matrix ZZ  <-- ZZ                                                    |
+--------------------------------------------------------------------------+
|i5 : X = smallCover(K, lambda)                                            |
|                                                                          |
|o5 = SmallCover{QTMCharacteristicMatrix => | 1 0 1 0 |                   }|
|                                           | 0 1 0 1 |                    |
|                QTMDimension => 2                                         |
|                QTMSimplicialComplex => simplicialComplex | cd ad bc ab | |
|                                                                          |
|o5 : SmallCover                                                           |
+--------------------------------------------------------------------------+

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

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

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

The source of this document is in ToricTopology/Documentation.m2:125:0.

stiefelWhitney -- compute the Stiefel-Whitney classes of a small cover
**********************************************************************

  * Usage:
        stiefelWhitney(N)
  * Inputs:
      * N, a small cover,
  * Outputs:
      * a list (Macaulay2Doc),

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

Compute the Stiefel-Whitney classes of a small cover. The output is a list of
elements in the cohomology ring of N.

+-----------------------------------------+
|i1 : stiefelWhitney realProjectiveSpace 2|
|                                         |
|             2                           |
|o1 = {1, c, c }                          |
|                                         |
|o1 : List                                |
+-----------------------------------------+
|i2 : stiefelWhitney realProjectiveSpace 3|
|                                         |
|o2 = {1, 0, 0, 0}                        |
|                                         |
|o2 : List                                |
+-----------------------------------------+
|i3 : stiefelWhitney hessenbergVariety 2  |
|                                         |
|o3 = {1, c + d, 0}                       |
|                                         |
|o3 : List                                |
+-----------------------------------------+

See also
========

  * cohomologyRing -- compute the cohomology ring of a
    small cover or quasitoric manifold

Ways to use stiefelWhitney:
===========================

  * "stiefelWhitney(SmallCover)"

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

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

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

The source of this document is in ToricTopology/Documentation.m2:287:0.