This is Topcom.info, produced by Macaulay2, version 1.22

Topcom -- interface to selected functions from topcom package
*************************************************************

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

Topcom (see https://www.wm.uni-bayreuth.de/de/team/rambau_joerg/TOPCOM/index.
html ) is mathematical software written by Jorg Rambau for computing and
manipulating triangulations of polytopes and chirotopes.

This Macaulay2 package provides an interface for some of the functionality of
this software.

The package is meant as an internal package, to be called by packages such as
Polyhedra.  It is highly recommended to use those
packages, rather than calling this package directly.

Example use of Topcom
=====================

  * An example use of TopCom -- interface to
    selected functions from topcom package

Generating triangulations
=========================

  * topcomAllTriangulations(Matrix),
    -- generate all triangulations of a point or vector configuration
  * topcomNumTriangulations(Matrix),
    -- the number of triangulations of a point or vector configuration

Useful functions involving specific triangulations
==================================================

  * topcomRegularFineTriangulation(Matrix)
    -- compute a regular
    triangulation using all of the given points
  * topcomIsTriangulation(Matrix,List)
    -- determine if a set of subsets
    is a triangulation of a point set
  * topcomIsRegularTriangulation(Matrix,List)
    -- determine if a given triangulation is a
    regular triangulation
  * topcomRegularTriangulationWeights(Matrix,List)
    -- find a list of
    heights of a regular triangulation

Useful functions involving bistellar flips
==========================================

  * topcomFlips(Matrix,List) -- find the
    neighboring triangulations (bistellar flips) of a triangulation
  * topcomNumFlips(Matrix,List), --
    find the number of neighboring triangulations (bistellar flips) of a
    triangulation

Chirotope functions
===================

The chirotope of a point set (or vector set), consisting of the columns of the
$d \times n$ matrix $A$, is the function which assigns to each $d+1 \times d+1$
minor of $\overline{A}$ the sign of its determinant.  Topcom encodes this into
a string.  See chirotopeString, for details
about the output of this function.

  * chirotopeString(Matrix) -- compute the
    chirotope string of a point or vector configuration
  * naiveChirotopeString(Matrix), --
    compute the chirotope string of a point or vector configuration
  * orientedCircuits(String) -- compute the oriented
    circuits of an oriented matroid or point or vector configuration
  * orientedCocircuits(String) -- compute the
    oriented cocircuits of an oriented matroid

See also
========

  * Polyhedra -- for computations with convex polyhedra,
    cones, and fans
  * Triangulations -- generating and manipulating
    triangulations of point or vector configurations
  * ReflexivePolytopesDB -- simple access to
    Kreuzer-Skarke database of reflexive polytopes of dimensions 3 and 4

Author
======

  * Mike Stillman (see http://www.math.cornell.edu/~mike )
    <mike@math.cornell.edu>

Version
=======

This documentation describes version 0.95 of Topcom.

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

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

Exports
=======

  * Functions and commands
      * "chirotopeString" -- see chirotopeString(Matrix),
        -- compute the chirotope string of a point
        or vector configuration
      * "naiveChirotopeString" -- see naiveChirotopeString(Matrix),
        -- compute the chirotope string of a
        point or vector configuration
      * orientedCircuits -- compute the oriented
        circuits of an oriented matroid or point or vector configuration
      * orientedCocircuits -- compute the oriented
        cocircuits of an oriented matroid
      * "topcomAllTriangulations" -- see topcomAllTriangulations(Matrix),
        -- generate all triangulations of
        a point or vector configuration
      * "topcomFlips" -- see topcomFlips(Matrix,List),
        -- find the neighboring triangulations
        (bistellar flips) of a triangulation
      * topcomIsRegularTriangulation, --
        determine if a given triangulation is a regular triangulation
      * "topcomIsTriangulation" -- see
        topcomIsTriangulation(Matrix,List),
        -- determine if a set of
        subsets is a triangulation of a point set
      * "topcomNumFlips" -- see topcomNumFlips(Matrix,List),
        -- find the number of neighboring
        triangulations (bistellar flips) of a triangulation
      * "topcomNumTriangulations" -- see topcomNumTriangulations(Matrix),
        -- the number of triangulations of
        a point or vector configuration
      * "topcomRegularFineTriangulation" -- see
        topcomRegularFineTriangulation(Matrix),
        -- compute a regular
        triangulation using all of the given points
      * "topcomRegularTriangulationWeights" -- see
        topcomRegularTriangulationWeights(Matrix,List),
        -- find a list of
        heights of a regular triangulation
  * Methods
      * chirotopeString(Matrix) -- compute
        the chirotope string of a point or vector configuration
      * naiveChirotopeString(Matrix),
        -- compute the chirotope string of a point or vector configuration
      * "orientedCircuits(Matrix)" -- see orientedCircuits,
        -- compute the oriented circuits of an oriented
        matroid or point or vector configuration
      * "orientedCircuits(String)" -- see orientedCircuits,
        -- compute the oriented circuits of an oriented
        matroid or point or vector configuration
      * "orientedCocircuits(Matrix)" -- see orientedCocircuits,
        -- compute the oriented cocircuits of an oriented
        matroid
      * "orientedCocircuits(String)" -- see orientedCocircuits,
        -- compute the oriented cocircuits of an oriented
        matroid
      * topcomAllTriangulations(Matrix)
        -- generate all triangulations of
        a point or vector configuration
      * topcomFlips(Matrix,List) -- find
        the neighboring triangulations (bistellar flips) of a triangulation
      * "topcomIsRegularTriangulation(Matrix,List)" -- see
        topcomIsRegularTriangulation, --
        determine if a given triangulation is a regular triangulation
      * topcomIsTriangulation(Matrix,List)
        -- determine if a set of
        subsets is a triangulation of a point set
      * topcomNumFlips(Matrix,List),
        -- find the number of neighboring triangulations (bistellar flips) of a
        triangulation
      * topcomNumTriangulations(Matrix)
        -- the number of triangulations of
        a point or vector configuration
      * topcomRegularFineTriangulation(Matrix)
        -- compute a regular
        triangulation using all of the given points
      * topcomRegularTriangulationWeights(Matrix,List)
        -- find a list of
        heights of a regular triangulation
  * Symbols
      * ConnectedToRegular -- an optional argument
        used in some functions in the Topcom interfacce package
      * Fine -- an optional argument used in some functions in the
        Topcom interfacce package
      * Homogenize -- an optional argument to most functions
        in Topcom to indicate whether to homogenize the matrix
      * RegularOnly -- an optional argument used in some
        functions in the Topcom interfacce package

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

The object Topcom, is a package (Macaulay2Doc).

An example use of TopCom -- interface to selected functions from topcom package
*******************************************************************************

Topcom is software written by Jorg Rambau which has very good support for
computing the triangulations of a point set (or, regular triangulations, fine
triangulations, and triangulations which are connected to regular
triangulations via bistellar flips).

Given a matrix $A$ (say of size $d \times n$), the columns represent points in
$d$-space, and each point is labelled by its column index ($0, 1, \ldots,
n-1$). Topcom appears to assume that the points are not contained in a
hyperplane.  In this case, their convex hull is full dimensional
($d$-dimensional), and a set of $d$-simplices with vertices in the set of
points is a triangulation if (1) their union is the convex hull of the columns
of $A$, and (2) the simplices either do not intersect, or intersect only along
lower dimensional sets.  We represent a triangulation by the the list of lists
of indices for each of these $d$-dimensional simplices.

For example, consider a simple example: the square.

+-----------------------------------------------------------------------------+
|i1 : sq = transpose matrix                                                   |
|                                                                             |
|o1 = | -1 -1 1  1 0 1 -1 0                                                   |
|     | -1 1  -1 1 0 0 0  1                                                   |
|                                                                             |
|              2        9                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
|-----------------------------------------------------------------------------|
|{{-1,-1},{-1,1},{1,-1},{1,1},{0,0},{1,0},{-1,0},{0,1},{0,-1}}                |
|                                                                             |
|0  |                                                                         |
|-1 |                                                                         |
+-----------------------------------------------------------------------------+
|i2 : tri = topcomRegularFineTriangulation sq                                 |
|                                                                             |
|o2 = {{2, 4, 5}, {3, 4, 5}, {0, 4, 6}, {1, 4, 6}, {3, 4, 7}, {1, 4, 7}, {2,  |
|     ------------------------------------------------------------------------|
|     4, 8}, {0, 4, 8}}                                                       |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : topcomIsTriangulation(sq, tri)                                          |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : topcomIsRegularTriangulation(sq, tri)                                   |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+
|i5 : topcomRegularTriangulationWeights(sq, tri)                              |
|                                                                             |
|o5 = {1, 1, 1, 1, -3, 0, 0, 0, 0}                                            |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : topcomNumTriangulations sq                                              |
|                                                                             |
|o6 = 387                                                                     |
+-----------------------------------------------------------------------------+
|i7 : topcomNumTriangulations(sq, Fine => true)                               |
|                                                                             |
|o7 = 64                                                                      |
+-----------------------------------------------------------------------------+
|i8 : Ts = topcomAllTriangulations(sq, Fine => true);                         |
+-----------------------------------------------------------------------------+
|i9 : netList Ts                                                              |
|                                                                             |
|     +---------+---------+---------+---------+---------+---------+---------+-|
|o9 = |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 6}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}|{3, 4, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}|{4, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}|{4, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 7}|{0, 5, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 6}|{3, 4, 8}|{3, 5, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 5}|{1, 4, 8}|{1, 5, 7}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 5, 7}|{4, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 6}|{2, 4, 7}|{2, 5, 7}|{2, 6, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}|{3, 4, 6}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 4, 5}|{1, 4, 8}|{1, 5, 7}|{1, 6, 8}|{2, 5, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 4, 6}|{2, 4, 7}|{2, 5, 7}|{2, 6, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 4, 5}|{0, 4, 7}|{0, 5, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|     |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 6}|{3, 4, 8}|{3, 5, 8}|{3, 6, 7}|{|
|     +---------+---------+---------+---------+---------+---------+---------+-|
|-----------------------------------------------------------------------------|
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|3, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|3, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|3, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|3, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 4, 7}|                                                                    |
|--------+                                                                    |
|3, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 8}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|3, 6, 7}|                                                                    |
|--------+                                                                    |
|3, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 8}|                                                                    |
|--------+                                                                    |
|4, 6, 7}|                                                                    |
|--------+                                                                    |
|4, 5, 7}|                                                                    |
|--------+                                                                    |
|4, 6, 8}|                                                                    |
|--------+                                                                    |
+-----------------------------------------------------------------------------+

Topcom assumes that the points do not lie on a hyperplane.  If they do, and the
hyperplane is not through the origin (and they span that entire affine
hyperplane), then give Homogenize => false as an option. This is essentially
equivalent to considering the point configuration as a vector comfiguration.

For example, the following three points lie on the hyperplane $x_0 + x_1 + x_2
= 2$.

+-------------------------------------------------------------+
|i10 : A1 = transpose matrix{{1,1,0},{1,0,1},{0,1,1}}         |
|                                                             |
|o10 = | 1 1 0 |                                              |
|      | 1 0 1 |                                              |
|      | 0 1 1 |                                              |
|                                                             |
|               3        3                                    |
|o10 : Matrix ZZ  <--- ZZ                                     |
+-------------------------------------------------------------+
|i11 : topcomRegularFineTriangulation(A1, Homogenize => false)|
|                                                             |
|o11 = {{0, 1, 2}}                                            |
|                                                             |
|o11 : List                                                   |
+-------------------------------------------------------------+
|i12 : topcomRegularFineTriangulation(A1, Homogenize => true) |
+-------------------------------------------------------------+

Topcom generates triangulations by starting with a triangulation, and
generating more by bistellar flips. There is a beautiful story about the
collection of all (regular, or connected to regular) triangulations of a point
or vector configuration.  See the book De Loera, Rambau, Santos, Triangulations
for details about this.

+-----------------------------------------------------------------------------+
|i13 : sqh = transpose matrix {{-1,-1,1},{-1,1,1},{1,-1,1},{1,1,1},{0,0,1},{1,|
|                                                                             |
|o13 = | -1 -1 1  1 0 1 -1 0 0  |                                             |
|      | -1 1  -1 1 0 0 0  1 -1 |                                             |
|      | 1  1  1  1 1 1 1  1 1  |                                             |
|                                                                             |
|               3        9                                                    |
|o13 : Matrix ZZ  <--- ZZ                                                     |
|-----------------------------------------------------------------------------|
|0,1},{-1,0,1},{0,1,1},{0,-1,1}}                                              |
+-----------------------------------------------------------------------------+
|i14 : tri = topcomRegularFineTriangulation sqh -- none found!                |
+-----------------------------------------------------------------------------+
|i15 : tri = topcomRegularFineTriangulation(sqh, Homogenize => false)         |
|                                                                             |
|o15 = {{2, 4, 5}, {3, 4, 5}, {0, 4, 6}, {1, 4, 6}, {3, 4, 7}, {1, 4, 7}, {2, |
|      -----------------------------------------------------------------------|
|      4, 8}, {0, 4, 8}}                                                      |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+
|i16 : topcomNumTriangulations(sqh, Homogenize => false)                      |
|                                                                             |
|o16 = 387                                                                    |
+-----------------------------------------------------------------------------+
|i17 : # topcomAllTriangulations(sqh, Homogenize => false)                    |
|                                                                             |
|o17 = 387                                                                    |
+-----------------------------------------------------------------------------+
|i18 : topcomIsTriangulation(sq, tri)                                         |
|                                                                             |
|o18 = true                                                                   |
+-----------------------------------------------------------------------------+
|i19 : topcomIsRegularTriangulation(sq, tri)                                  |
|                                                                             |
|o19 = true                                                                   |
+-----------------------------------------------------------------------------+
|i20 : topcomRegularTriangulationWeights(sq, tri)                             |
|                                                                             |
|o20 = {1, 1, 1, 1, -3, 0, 0, 0, 0}                                           |
|                                                                             |
|o20 : List                                                                   |
+-----------------------------------------------------------------------------+
|i21 : topcomNumTriangulations sq                                             |
|                                                                             |
|o21 = 387                                                                    |
+-----------------------------------------------------------------------------+
|i22 : topcomNumTriangulations(sq, Fine => true)                              |
|                                                                             |
|o22 = 64                                                                     |
+-----------------------------------------------------------------------------+
|i23 : Ts = topcomAllTriangulations(sq, Fine => true);                        |
+-----------------------------------------------------------------------------+
|i24 : netList Ts                                                             |
|                                                                             |
|      +---------+---------+---------+---------+---------+---------+---------+|
|o24 = |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 6}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 7}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 7}|{4, 5, 8}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}|{4, 5, 7}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}|{3, 4, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 5}|{2, 4, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}|{3, 5, 7}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}|{3, 5, 8}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}|{4, 5, 8}|{4, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}|{3, 6, 7}|{4, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 6}|{0, 5, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}|{3, 4, 6}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 7}|{0, 5, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 6}|{0, 4, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 6}|{3, 4, 8}|{3, 5, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 4, 7}|{3, 4, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 5}|{1, 4, 8}|{1, 5, 7}|{1, 6, 8}|{2, 4, 5}|{2, 4, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 7}|{1, 4, 8}|{1, 6, 8}|{2, 4, 7}|{2, 4, 8}|{2, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 7}|{0, 4, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 5, 7}|{4, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 6}|{1, 4, 7}|{2, 4, 6}|{2, 4, 7}|{2, 5, 7}|{2, 6, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}|{3, 4, 5}|{3, 4, 6}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 5}|{1, 4, 6}|{1, 5, 7}|{2, 4, 5}|{2, 4, 6}|{2, 6, 8}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 4, 5}|{1, 4, 8}|{1, 5, 7}|{1, 6, 8}|{2, 5, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 4, 6}|{2, 4, 7}|{2, 5, 7}|{2, 6, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 4, 5}|{0, 4, 7}|{0, 5, 8}|{0, 6, 7}|{1, 6, 7}|{2, 5, 8}|{3, 5, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 6, 8}|{1, 6, 7}|{2, 5, 8}|{3, 4, 6}|{3, 4, 8}|{3, 5, 8}|{3, 6, 7}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|-----------------------------------------------------------------------------|
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{3, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{3, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{3, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{3, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 4, 7}|                                                                   |
|---------+                                                                   |
|{3, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 8}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{3, 6, 7}|                                                                   |
|---------+                                                                   |
|{3, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 8}|                                                                   |
|---------+                                                                   |
|{4, 6, 7}|                                                                   |
|---------+                                                                   |
|{4, 5, 7}|                                                                   |
|---------+                                                                   |
|{4, 6, 8}|                                                                   |
|---------+                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * topcomIsTriangulation(Matrix,List)
    -- determine if a set of subsets
    is a triangulation of a point set
  * topcomIsRegularTriangulation(Matrix,List)
    -- determine if a given triangulation is a
    regular triangulation
  * topcomRegularFineTriangulation(Matrix)
    -- compute a regular
    triangulation using all of the given points
  * topcomAllTriangulations(Matrix),
    -- generate all triangulations of a point or vector configuration
  * topcomNumTriangulations(Matrix),
    -- the number of triangulations of a point or vector configuration
  * topcomRegularTriangulationWeights(Matrix,List)
    -- find a list of
    heights of a regular triangulation

chirotopeString(Matrix) -- compute the chirotope string of a point or vector configuration
******************************************************************************************

Synopsis
========

  * Function: chirotopeString,
  * Usage:
        chirotopeString A
  * Inputs:
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a string (Macaulay2Doc),

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

Let $A^h$ be the matrix obtained from $A$ by adding a row of one's (called the
homogenization of $A$).  Sort all of the subsets of size $d+1$ of $0, \ldots,
n-1$ lexicographically. The resulting string has two parts: the header, which
has $n$ and $d+1$, and then a single string consisting of "0", "-" and "+", one
for each subset, where the character records the sign of the determinant of the
submatrix consisting of the columns in the subset.

+----------------------------------------+
|i1 : A = matrix {                       |
|         {0, -1, 2, 3, 4, -5, 6},       |
|         {0, 1, -4, 9, 16, 25, 36},     |
|         {0, 1, 8, -27, 64, 125, -216}} |
|                                        |
|o1 = | 0 -1 2  3   4  -5  6    |        |
|     | 0 1  -4 9   16 25  36   |        |
|     | 0 1  8  -27 64 125 -216 |        |
|                                        |
|              3        7                |
|o1 : Matrix ZZ  <--- ZZ                 |
+----------------------------------------+
|i2 : om = chirotopeString A             |
|                                        |
|o2 = 7,4:                               |
|     ---0++-+----+-++++++--+-+++++++-+++|
+----------------------------------------+
|i3 : om == naiveChirotopeString A       |
|                                        |
|o3 = true                               |
+----------------------------------------+

Topcom often works as follows: it creates the oriented matroid (string, or an
internal version of it), and uses that to find triangulations.  It is important
to note that one can find all triangulations this way.  However, one needs the
matrix $A$ to be able to determine if a given triangulation is regular.

+-----------------------------------------------------------------------------+
|i4 : orientedCircuits om                                                     |
|                                                                             |
|o4 = {{{0}, {1, 2, 6}}, {{0, 2, 4, 6}, {3}}, {{0, 3}, {2, 5, 6}}, {{0, 3, 5},|
|     ------------------------------------------------------------------------|
|     {1, 4}}, {{0, 4}, {1, 2, 3}}, {{0, 4}, {2, 3, 5}}, {{0, 4}, {2, 5, 6}}, |
|     ------------------------------------------------------------------------|
|     {{0, 4, 6}, {1, 3}}, {{0, 4, 6}, {3, 5}}, {{0, 5}, {1, 2, 3}}, {{0, 5}, |
|     ------------------------------------------------------------------------|
|     {1, 2, 4}}, {{0, 5, 6}, {1, 3}}, {{0, 5, 6}, {1, 4}}, {{1, 2, 4, 6},    |
|     ------------------------------------------------------------------------|
|     {3}}, {{1, 3}, {2, 5, 6}}, {{1, 4}, {2, 3, 5}}, {{1, 4}, {2, 5, 6}},    |
|     ------------------------------------------------------------------------|
|     {{1, 4, 6}, {3, 5}}, {{2, 4, 5, 6}, {3}}}                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : orientedCocircuits om                                                   |
|                                                                             |
|o5 = {{{0, 2}, {4, 5}}, {{1, 5}, {3, 6}}, {{1, 4, 5}, {2}}, {{2, 5}, {3, 6}},|
|     ------------------------------------------------------------------------|
|     {{3, 4, 5}, {}}, {{0, 6}, {4, 5}}, {{1, 4, 5}, {6}}, {{2, 4, 5}, {6}},  |
|     ------------------------------------------------------------------------|
|     {{0, 1, 2, 3}, {}}, {{0, 1, 2}, {6}}, {{0, 1, 3, 6}, {}}, {{0, 1, 2},   |
|     ------------------------------------------------------------------------|
|     {4}}, {{0, 2}, {3, 6}}, {{1, 3, 6}, {2}}, {{0, 1}, {3, 4}}, {{0, 2, 3,  |
|     ------------------------------------------------------------------------|
|     4}, {}}, {{0, 1, 6}, {4}}, {{1}, {2, 3, 4}}, {{0, 2, 4}, {6}}, {{1, 6}, |
|     ------------------------------------------------------------------------|
|     {2, 4}}, {{0, 3, 4, 6}, {}}, {{1}, {3, 4, 6}}, {{0, 1, 5}, {2}}, {{2},  |
|     ------------------------------------------------------------------------|
|     {3, 4, 6}}, {{0, 1, 3, 5}, {}}, {{0, 2, 3}, {5}}, {{0, 1, 5}, {6}}, {{1,|
|     ------------------------------------------------------------------------|
|     5}, {2, 3}}, {{0, 2}, {5, 6}}, {{1, 5, 6}, {2}}, {{0, 1, 5}, {4}}, {{0, |
|     ------------------------------------------------------------------------|
|     3, 6}, {5}}}                                                            |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

If the number of minors of size $(d+1) \times (d+1)$ of $A^h$ is too large,
then this won't work so well....! For example, in dimension 4, with 100
vertices, the number of such determinants is about 75 million.  That is fine
perhaps, but for 200 vertices, the size jumps to 2.5 billion.

See also
========

  * naiveChirotopeString(Matrix), --
    compute the chirotope string of a point or vector configuration
  * orientedCircuits(String) -- compute the oriented
    circuits of an oriented matroid or point or vector configuration
  * orientedCocircuits(String) -- compute the
    oriented cocircuits of an oriented matroid

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

  * chirotopeString(Matrix) -- compute the
    chirotope string of a point or vector configuration

ConnectedToRegular -- an optional argument used in some functions in the Topcom interfacce package
**************************************************************************************************

Functions with optional argument named ConnectedToRegular :
===========================================================

  * "topcomAllTriangulations(...,ConnectedToRegular=>...)" -- see
    topcomAllTriangulations(Matrix), --
    generate all triangulations of a point or vector configuration
  * "topcomNumTriangulations(...,ConnectedToRegular=>...)" -- see
    topcomNumTriangulations(Matrix), --
    the number of triangulations of a point or vector configuration

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

The object ConnectedToRegular, is a symbol (Macaulay2Doc).

Fine -- an optional argument used in some functions in the Topcom interfacce package
************************************************************************************

Functions with optional argument named Fine :
=============================================

  * "topcomAllTriangulations(...,Fine=>...)" -- see
    topcomAllTriangulations(Matrix), --
    generate all triangulations of a point or vector configuration
  * "topcomNumTriangulations(...,Fine=>...)" -- see
    topcomNumTriangulations(Matrix), --
    the number of triangulations of a point or vector configuration

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

The object Fine, is a symbol (Macaulay2Doc).

Homogenize -- an optional argument to most functions in Topcom to indicate whether to homogenize the matrix
***********************************************************************************************************

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

Most functions in this package take a $d \times n$ matrix $A$, representing a
point or vector configuration: the columns are the points or vectors.  Topcom's
input is always a matrix representing a vector configuration.  A matrix $A$
whose columns represent a point configuration can be "homogenized" to a vector
configuration by adding a row of ones to $A$, forming a $(d+1) \times n$ matrix
$A^h$.

Functions with optional argument named Homogenize :
===================================================

  * "chirotopeString(...,Homogenize=>...)" -- see
    chirotopeString(Matrix), -- compute the
    chirotope string of a point or vector configuration
  * "naiveChirotopeString(...,Homogenize=>...)" -- see
    naiveChirotopeString(Matrix), -- compute
    the chirotope string of a point or vector configuration
  * "orientedCircuits(...,Homogenize=>...)" -- see orientedCircuits,
    -- compute the oriented circuits of an oriented matroid
    or point or vector configuration
  * "orientedCocircuits(...,Homogenize=>...)" -- see orientedCocircuits,
    -- compute the oriented cocircuits of an oriented
    matroid
  * "topcomAllTriangulations(...,Homogenize=>...)" -- see
    topcomAllTriangulations(Matrix), --
    generate all triangulations of a point or vector configuration
  * "topcomFlips(...,Homogenize=>...)" -- see topcomFlips(Matrix,List),
    -- find the neighboring triangulations
    (bistellar flips) of a triangulation
  * "topcomIsRegularTriangulation(...,Homogenize=>...)" -- see
    topcomIsRegularTriangulation, -- determine if
    a given triangulation is a regular triangulation
  * "topcomIsTriangulation(...,Homogenize=>...)" -- see
    topcomIsTriangulation(Matrix,List),
    -- determine if a set of subsets
    is a triangulation of a point set
  * "topcomNumFlips(...,Homogenize=>...)" -- see
    topcomNumFlips(Matrix,List), -- find the
    number of neighboring triangulations (bistellar flips) of a triangulation
  * "topcomNumTriangulations(...,Homogenize=>...)" -- see
    topcomNumTriangulations(Matrix), --
    the number of triangulations of a point or vector configuration
  * "topcomRegularFineTriangulation(...,Homogenize=>...)" -- see
    topcomRegularFineTriangulation(Matrix),
    -- compute a regular
    triangulation using all of the given points
  * "topcomRegularTriangulationWeights(...,Homogenize=>...)" -- see
    topcomRegularTriangulationWeights(Matrix,List),
    -- find a list of
    heights of a regular triangulation

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

The object Homogenize, is a symbol (Macaulay2Doc).

naiveChirotopeString(Matrix) -- compute the chirotope string of a point or vector configuration
***********************************************************************************************

Synopsis
========

  * Function: naiveChirotopeString,
  * Usage:
        naiveChirotopeString A
  * Inputs:
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a string (Macaulay2Doc),

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

This is a simple function written in Macaulay2 to generate the same output as
chirotopeString(Matrix).  However, it is
much slower.  But we wrote it to make sure we know what order Topcom is
generating the determinants.

+----------------------------------------+
|i1 : A = matrix {                       |
|         {0, -1, 2, 3, 4, -5, 6},       |
|         {0, 1, -4, 9, 16, 25, 36},     |
|         {0, 1, 8, -27, 64, 125, -216}} |
|                                        |
|o1 = | 0 -1 2  3   4  -5  6    |        |
|     | 0 1  -4 9   16 25  36   |        |
|     | 0 1  8  -27 64 125 -216 |        |
|                                        |
|              3        7                |
|o1 : Matrix ZZ  <--- ZZ                 |
+----------------------------------------+
|i2 : om = naiveChirotopeString A        |
|                                        |
|o2 = 7,4:                               |
|     ---0++-+----+-++++++--+-+++++++-+++|
+----------------------------------------+
|i3 : om == chirotopeString A            |
|                                        |
|o3 = true                               |
+----------------------------------------+

See also
========

  * chirotopeString(Matrix) -- compute the
    chirotope string of a point or vector configuration
  * orientedCircuits(String) -- compute the oriented
    circuits of an oriented matroid or point or vector configuration
  * orientedCocircuits(String) -- compute the
    oriented cocircuits of an oriented matroid

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

  * naiveChirotopeString(Matrix), --
    compute the chirotope string of a point or vector configuration

orientedCircuits -- compute the oriented circuits of an oriented matroid or point or vector configuration
*********************************************************************************************************

Synopsis
========

  * Usage:
        orientedCircuits om
        orientedCocircuits A
  * Inputs:
      * om, a string (Macaulay2Doc),
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true, Only valid in the second form.
  * Outputs:
      * a list (Macaulay2Doc),

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

An oriented circuit is determined by a linear relationship on the columns of
(the augmented matrix of) $A$, of minimal support.  The circuit is the pair of
lists of indices of the columns where the coefficients is positive
(respectively negative).

+----------------------------------------+
|i1 : A = matrix {                       |
|         {0, -1, 2, 3, 4, -5, 6},       |
|         {0, 1, -4, 9, 16, 25, 36},     |
|         {0, 1, 8, -27, 64, 125, -216}} |
|                                        |
|o1 = | 0 -1 2  3   4  -5  6    |        |
|     | 0 1  -4 9   16 25  36   |        |
|     | 0 1  8  -27 64 125 -216 |        |
|                                        |
|              3        7                |
|o1 : Matrix ZZ  <--- ZZ                 |
+----------------------------------------+
|i2 : om = naiveChirotopeString A        |
|                                        |
|o2 = 7,4:                               |
|     ---0++-+----+-++++++--+-+++++++-+++|
+----------------------------------------+
|i3 : netList orientedCircuits om        |
|                                        |
|     +------------+---------+           |
|o3 = |{0}         |{1, 2, 6}|           |
|     +------------+---------+           |
|     |{0, 2, 4, 6}|{3}      |           |
|     +------------+---------+           |
|     |{0, 3}      |{2, 5, 6}|           |
|     +------------+---------+           |
|     |{0, 3, 5}   |{1, 4}   |           |
|     +------------+---------+           |
|     |{0, 4}      |{1, 2, 3}|           |
|     +------------+---------+           |
|     |{0, 4}      |{2, 3, 5}|           |
|     +------------+---------+           |
|     |{0, 4}      |{2, 5, 6}|           |
|     +------------+---------+           |
|     |{0, 4, 6}   |{1, 3}   |           |
|     +------------+---------+           |
|     |{0, 4, 6}   |{3, 5}   |           |
|     +------------+---------+           |
|     |{0, 5}      |{1, 2, 3}|           |
|     +------------+---------+           |
|     |{0, 5}      |{1, 2, 4}|           |
|     +------------+---------+           |
|     |{0, 5, 6}   |{1, 3}   |           |
|     +------------+---------+           |
|     |{0, 5, 6}   |{1, 4}   |           |
|     +------------+---------+           |
|     |{1, 2, 4, 6}|{3}      |           |
|     +------------+---------+           |
|     |{1, 3}      |{2, 5, 6}|           |
|     +------------+---------+           |
|     |{1, 4}      |{2, 3, 5}|           |
|     +------------+---------+           |
|     |{1, 4}      |{2, 5, 6}|           |
|     +------------+---------+           |
|     |{1, 4, 6}   |{3, 5}   |           |
|     +------------+---------+           |
|     |{2, 4, 5, 6}|{3}      |           |
|     +------------+---------+           |
+----------------------------------------+

Let's look at the linear relation giving rise to $\{\{0,3\}, \{ 2, 5, 6\}\}$.

+--------------------------------+
|i4 : Ahomog = A || matrix{{7:1}}|
|                                |
|o4 = | 0 -1 2  3   4  -5  6    ||
|     | 0 1  -4 9   16 25  36   ||
|     | 0 1  8  -27 64 125 -216 ||
|     | 1 1  1  1   1  1   1    ||
|                                |
|              4        7        |
|o4 : Matrix ZZ  <--- ZZ         |
+--------------------------------+
|i5 : Ahomog_{0,3,2,5,6}         |
|                                |
|o5 = | 0 3   2  -5  6    |      |
|     | 0 9   -4 25  36   |      |
|     | 0 -27 8  125 -216 |      |
|     | 1 1   1  1   1    |      |
|                                |
|              4        5        |
|o5 : Matrix ZZ  <--- ZZ         |
+--------------------------------+
|i6 : syz oo                     |
|                                |
|o6 = | -242 |                   |
|     | -440 |                   |
|     | 495  |                   |
|     | 72   |                   |
|     | 115  |                   |
|                                |
|              5        1        |
|o6 : Matrix ZZ  <--- ZZ         |
+--------------------------------+

See also
========

  * chirotopeString(Matrix) -- compute the
    chirotope string of a point or vector configuration
  * orientedCocircuits -- compute the oriented
    cocircuits of an oriented matroid

Ways to use orientedCircuits :
==============================

  * "orientedCircuits(Matrix)"
  * "orientedCircuits(String)"

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

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

orientedCocircuits -- compute the oriented cocircuits of an oriented matroid
****************************************************************************

Synopsis
========

  * Usage:
        orientedCocircuits om
        orientedCocircuits A
  * Inputs:
      * om, a string (Macaulay2Doc), representing a chirotope
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true, Only valid in the second form.
  * Outputs:
      * a list (Macaulay2Doc),

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

See also
========

  * chirotopeString -- compute the
    chirotope string of a point or vector configuration
  * orientedCircuits -- compute the oriented circuits
    of an oriented matroid or point or vector configuration

Ways to use orientedCocircuits :
================================

  * "orientedCocircuits(Matrix)"
  * "orientedCocircuits(String)"

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

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

RegularOnly -- an optional argument used in some functions in the Topcom interfacce package
*******************************************************************************************

Functions with optional argument named RegularOnly :
====================================================

  * "topcomAllTriangulations(...,RegularOnly=>...)" -- see
    topcomAllTriangulations(Matrix), --
    generate all triangulations of a point or vector configuration
  * "topcomFlips(...,RegularOnly=>...)" -- see topcomFlips(Matrix,List),
    -- find the neighboring triangulations
    (bistellar flips) of a triangulation
  * "topcomNumFlips(...,RegularOnly=>...)" -- see
    topcomNumFlips(Matrix,List), -- find the
    number of neighboring triangulations (bistellar flips) of a triangulation
  * "topcomNumTriangulations(...,RegularOnly=>...)" -- see
    topcomNumTriangulations(Matrix), --
    the number of triangulations of a point or vector configuration

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

The object RegularOnly, is a symbol (Macaulay2Doc).

topcomAllTriangulations(Matrix) -- generate all triangulations of a point or vector configuration
*************************************************************************************************

Synopsis
========

  * Function: topcomAllTriangulations,
  * Usage:
        topcomAllTriangulations A
        topcomAllTriangulations(A, Homogenize => true, Fine => true, RegularOnly => true)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
      * ConnectedToRegular => a Boolean value (Macaulay2Doc),
        default value true
      * Fine => a Boolean value (Macaulay2Doc), default value
        false
      * RegularOnly => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a list (Macaulay2Doc),

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

This function constructs all triangulations of the point set corresponding to
$A$ (or triangulation of the cone over $A$, if Homogenize => false is given).
With no optional arguments, the default is to construct all regular
triangulations.

A triangulation is a list of lists of the indices of the maximal simplices in
the triangulation. (the index of the point corresponding to the $i$-th column
(starting at $0$) is simply $i$).

For example, the following point set is the smallest which has a non-regular
triangulation. Note that topcomAllTriangulations(Matrix),
only generates all the regular
triangulations.

+-----------------------------------------------------------------------------+
|i1 : A = transpose matrix {{0,3},{0,1},{-1,-1},{1,-1},{-4,-2},{4,-2}}        |
|                                                                             |
|o1 = | 0 0 -1 1  -4 4  |                                                     |
|     | 3 1 -1 -1 -2 -2 |                                                     |
|                                                                             |
|              2        6                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i2 : Ts = topcomAllTriangulations A;                                         |
+-----------------------------------------------------------------------------+
|i3 : #Ts == 16                                                               |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : netList Ts                                                              |
|                                                                             |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|o4 = |{0, 1, 2}|{0, 1, 3}|{0, 2, 4}|{0, 3, 5}|{1, 2, 3}|{2, 3, 4}|{3, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 2, 3}|{0, 2, 4}|{0, 3, 5}|{2, 3, 4}|{3, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 3}|{0, 1, 4}|{0, 3, 5}|{1, 2, 3}|{1, 2, 4}|{2, 3, 4}|{3, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 2}|{0, 1, 3}|{0, 2, 4}|{0, 3, 5}|{1, 2, 3}|{2, 3, 5}|{2, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 4}|{0, 1, 5}|{1, 2, 3}|{1, 2, 4}|{1, 3, 5}|{2, 3, 4}|{3, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 3}|{0, 1, 4}|{0, 3, 5}|{1, 3, 4}|{3, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 2, 3}|{0, 2, 4}|{0, 3, 5}|{2, 3, 5}|{2, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 2}|{0, 1, 5}|{0, 2, 4}|{1, 2, 3}|{1, 3, 5}|{2, 3, 5}|{2, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 3, 4}|{0, 3, 5}|{3, 4, 5}|         |         |         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 2, 4}|{0, 2, 5}|{2, 4, 5}|         |         |         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 4}|{0, 1, 5}|{1, 3, 4}|{1, 3, 5}|{3, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 4}|{0, 1, 5}|{1, 2, 3}|{1, 2, 4}|{1, 3, 5}|{2, 3, 5}|{2, 4, 5}| |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 2}|{0, 1, 5}|{0, 2, 4}|{1, 2, 5}|{2, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 4, 5}|         |         |         |         |         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 4}|{0, 1, 5}|{1, 4, 5}|         |         |         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
|     |{0, 1, 4}|{0, 1, 5}|{1, 2, 4}|{1, 2, 5}|{2, 4, 5}|         |         | |
|     +---------+---------+---------+---------+---------+---------+---------+ |
+-----------------------------------------------------------------------------+
|i5 : tri = Ts#0                                                              |
|                                                                             |
|o5 = {{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, 4}, {3,  |
|     ------------------------------------------------------------------------|
|     4, 5}}                                                                  |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : topcomIsTriangulation(A, tri)                                           |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+
|i7 : topcomIsRegularTriangulation(A, tri)                                    |
|                                                                             |
|o7 = true                                                                    |
+-----------------------------------------------------------------------------+
|i8 : topcomRegularTriangulationWeights(A, tri)                               |
|                                                                             |
|      97  47  1                                                              |
|o8 = {--, --, -, 0, 0, 0}                                                    |
|       8   8  4                                                              |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+

The following code determines the support of each triangulation, and tallies
them. Thus for example, we see that there are 6 regular fine triangulations
(fine means that all of the points are begin used).

+-----------------------------------------------------+
|i9 : tally for tri in Ts list sort unique flatten tri|
|                                                     |
|o9 = Tally{{0, 1, 2, 3, 4, 5} => 6}                  |
|           {0, 1, 2, 4, 5} => 2                      |
|           {0, 1, 3, 4, 5} => 2                      |
|           {0, 1, 4, 5} => 1                         |
|           {0, 2, 3, 4, 5} => 2                      |
|           {0, 2, 4, 5} => 1                         |
|           {0, 3, 4, 5} => 1                         |
|           {0, 4, 5} => 1                            |
|                                                     |
|o9 : Tally                                           |
+-----------------------------------------------------+

The method that topcom uses depends on the optional arguments Fine,
ConnectedToRegular and RegularOnly.

+---------------------------------------------+
|i10 : options topcomAllTriangulations        |
|                                             |
|o10 = OptionTable{ConnectedToRegular => true}|
|                  Fine => false              |
|                  Homogenize => true         |
|                  RegularOnly => true        |
|                                             |
|o10 : OptionTable                            |
+---------------------------------------------+

If the optional argument Fine is set to true, then only fine triangulations
(i.e. those that involve every column of $A$) will be generated.

+----------------------------------------------------+
|i11 : Ts = topcomAllTriangulations(A, Fine => true);|
+----------------------------------------------------+
|i12 : #Ts == 6                                      |
|                                                    |
|o12 = true                                          |
+----------------------------------------------------+

If the optional argument RegularOnly is set to false, but ConnectedToRegular is
true, it will generally take less time, as the program doesn't need to check
each triangulation to see if it is regular.

+-----------------------------------------------------------------------------+
|i13 : T1s = topcomAllTriangulations(A, RegularOnly => true)                  |
|                                                                             |
|o13 = {{{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, 4}, {3,|
|      -----------------------------------------------------------------------|
|      4, 5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3, 5}, {2, 3, 4}, {3, 4, 5}}, {{0,  |
|      -----------------------------------------------------------------------|
|      1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 2, 3}, {1, 2, 4}, {2, 3, 4}, {3, 4,   |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, 5},|
|      -----------------------------------------------------------------------|
|      {2, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 3}, {1, 2, 4}, {1, 3, 5}, {2,|
|      -----------------------------------------------------------------------|
|      3, 4}, {3, 4, 5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 3, 4}, {3, 4, |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3, 5}, {2, 3, 5}, {2, 4, 5}}, {{0, 1,  |
|      -----------------------------------------------------------------------|
|      2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 3}, {1, 3, 5}, {2, 3, 5}, {2, 4, 5}}, |
|      -----------------------------------------------------------------------|
|      {{0, 3, 4}, {0, 3, 5}, {3, 4, 5}}, {{0, 2, 4}, {0, 2, 5}, {2, 4, 5}},  |
|      -----------------------------------------------------------------------|
|      {{0, 1, 4}, {0, 1, 5}, {1, 3, 4}, {1, 3, 5}, {3, 4, 5}}, {{0, 1, 4},   |
|      -----------------------------------------------------------------------|
|      {0, 1, 5}, {1, 2, 3}, {1, 2, 4}, {1, 3, 5}, {2, 3, 5}, {2, 4, 5}}, {{0,|
|      -----------------------------------------------------------------------|
|      1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 5}, {2, 4, 5}}, {{0, 4, 5}}, {{0,  |
|      -----------------------------------------------------------------------|
|      1, 4}, {0, 1, 5}, {1, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 4}, {1, 2, |
|      -----------------------------------------------------------------------|
|      5}, {2, 4, 5}}}                                                        |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : T2s = topcomAllTriangulations(A, RegularOnly => false)                 |
|                                                                             |
|o14 = {{{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, 4}, {3,|
|      -----------------------------------------------------------------------|
|      4, 5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 3}, {1, 3, 5}, {2, 3, |
|      -----------------------------------------------------------------------|
|      4}, {3, 4, 5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3, 5}, {2, 3, 4}, {3, 4,    |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 2, 3}, {1, 2, 4}, {2, 3, 4},|
|      -----------------------------------------------------------------------|
|      {3, 4, 5}}, {{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2,|
|      -----------------------------------------------------------------------|
|      3, 5}, {2, 4, 5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3, 5}, {2, 3, 5}, {2, 4, |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 3}, {1, 3, 5}, {2, 3, 5},|
|      -----------------------------------------------------------------------|
|      {2, 4, 5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 2, 3}, {1, 2, 4}, {2,|
|      -----------------------------------------------------------------------|
|      3, 5}, {2, 4, 5}}, {{0, 3, 4}, {0, 3, 5}, {3, 4, 5}}, {{0, 1, 4}, {0,  |
|      -----------------------------------------------------------------------|
|      1, 5}, {1, 2, 3}, {1, 2, 4}, {1, 3, 5}, {2, 3, 4}, {3, 4, 5}}, {{0, 1, |
|      -----------------------------------------------------------------------|
|      3}, {0, 1, 4}, {0, 3, 5}, {1, 3, 4}, {3, 4, 5}}, {{0, 1, 4}, {0, 1, 5},|
|      -----------------------------------------------------------------------|
|      {1, 3, 4}, {1, 3, 5}, {3, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 3}, {1,|
|      -----------------------------------------------------------------------|
|      2, 4}, {1, 3, 5}, {2, 3, 5}, {2, 4, 5}}, {{0, 4, 5}}, {{0, 2, 4}, {0,  |
|      -----------------------------------------------------------------------|
|      2, 5}, {2, 4, 5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 5}, {2, 4, |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 4}, {1, 2, 5}, {2, 4, 5}}, {{0, 1,  |
|      -----------------------------------------------------------------------|
|      4}, {0, 1, 5}, {1, 4, 5}}}                                             |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
|i15 : #T1s                                                                   |
|                                                                             |
|o15 = 16                                                                     |
+-----------------------------------------------------------------------------+
|i16 : #T2s                                                                   |
|                                                                             |
|o16 = 18                                                                     |
+-----------------------------------------------------------------------------+

The following search yields all triangulations, even those not connected via
bistellar flips to regular triangulations.

+-----------------------------------------------------------------------------+
|i17 : T3s = topcomAllTriangulations(A, RegularOnly => false, ConnectedToRegul|
|                                                                             |
|o17 = {{{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, 4}, {3,|
|      -----------------------------------------------------------------------|
|      4, 5}}, {{0, 1, 2}, {0, 1, 3}, {0, 2, 4}, {0, 3, 5}, {1, 2, 3}, {2, 3, |
|      -----------------------------------------------------------------------|
|      5}, {2, 4, 5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 3}, {1, 3, 5},|
|      -----------------------------------------------------------------------|
|      {2, 3, 4}, {3, 4, 5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, 3}, {1,|
|      -----------------------------------------------------------------------|
|      3, 5}, {2, 3, 5}, {2, 4, 5}}, {{0, 1, 2}, {0, 1, 5}, {0, 2, 4}, {1, 2, |
|      -----------------------------------------------------------------------|
|      5}, {2, 4, 5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 2, 3}, {1, 2, 4},|
|      -----------------------------------------------------------------------|
|      {2, 3, 4}, {3, 4, 5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 2, 3}, {1,|
|      -----------------------------------------------------------------------|
|      2, 4}, {2, 3, 5}, {2, 4, 5}}, {{0, 1, 3}, {0, 1, 4}, {0, 3, 5}, {1, 3, |
|      -----------------------------------------------------------------------|
|      4}, {3, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 3}, {1, 2, 4}, {1, 3, 5},|
|      -----------------------------------------------------------------------|
|      {2, 3, 4}, {3, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 3}, {1, 2, 4}, {1,|
|      -----------------------------------------------------------------------|
|      3, 5}, {2, 3, 5}, {2, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 2, 4}, {1, 2, |
|      -----------------------------------------------------------------------|
|      5}, {2, 4, 5}}, {{0, 1, 4}, {0, 1, 5}, {1, 3, 4}, {1, 3, 5}, {3, 4,    |
|      -----------------------------------------------------------------------|
|      5}}, {{0, 1, 4}, {0, 1, 5}, {1, 4, 5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3,  |
|      -----------------------------------------------------------------------|
|      5}, {2, 3, 4}, {3, 4, 5}}, {{0, 2, 3}, {0, 2, 4}, {0, 3, 5}, {2, 3, 5},|
|      -----------------------------------------------------------------------|
|      {2, 4, 5}}, {{0, 2, 4}, {0, 2, 5}, {2, 4, 5}}, {{0, 3, 4}, {0, 3, 5},  |
|      -----------------------------------------------------------------------|
|      {3, 4, 5}}, {{0, 4, 5}}}                                               |
|                                                                             |
|o17 : List                                                                   |
|-----------------------------------------------------------------------------|
|ar => false)                                                                 |
+-----------------------------------------------------------------------------+
|i18 : #T3s                                                                   |
|                                                                             |
|o18 = 18                                                                     |
+-----------------------------------------------------------------------------+

Given the list of triangulations, we can query them using other topcom
functions. See also Triangulations, for other
functionality.

+-----------------------------------------------------------------------------+
|i19 : netList Ts                                                             |
|                                                                             |
|      +---------+---------+---------+---------+---------+---------+---------+|
|o19 = |{0, 1, 2}|{0, 1, 3}|{0, 2, 4}|{0, 3, 5}|{1, 2, 3}|{2, 3, 4}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 1, 2}|{0, 1, 3}|{0, 2, 4}|{0, 3, 5}|{1, 2, 3}|{2, 3, 5}|{2, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 1, 3}|{0, 1, 4}|{0, 3, 5}|{1, 2, 3}|{1, 2, 4}|{2, 3, 4}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 1, 4}|{0, 1, 5}|{1, 2, 3}|{1, 2, 4}|{1, 3, 5}|{2, 3, 4}|{3, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 1, 2}|{0, 1, 5}|{0, 2, 4}|{1, 2, 3}|{1, 3, 5}|{2, 3, 5}|{2, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
|      |{0, 1, 4}|{0, 1, 5}|{1, 2, 3}|{1, 2, 4}|{1, 3, 5}|{2, 3, 5}|{2, 4, 5}||
|      +---------+---------+---------+---------+---------+---------+---------+|
+-----------------------------------------------------------------------------+
|i20 : for tri in Ts list topcomIsTriangulation(A, tri)                       |
|                                                                             |
|o20 = {true, true, true, true, true, true}                                   |
|                                                                             |
|o20 : List                                                                   |
+-----------------------------------------------------------------------------+
|i21 : for tri in Ts list topcomIsRegularTriangulation(A, tri)                |
|                                                                             |
|o21 = {true, true, true, true, true, true}                                   |
|                                                                             |
|o21 : List                                                                   |
+-----------------------------------------------------------------------------+
|i22 : for tri in Ts list topcomRegularTriangulationWeights(A, tri)           |
|                                                                             |
|        97  47  1             87  41    1             157  15  1             |
|o22 = {{--, --, -, 0, 0, 0}, {--, --, - -, 0, 0, 0}, {---, --, -, 0, 0, 0},  |
|         8   8  4              8   8    4              20   4  2             |
|      -----------------------------------------------------------------------|
|       45  19  1             107  9    1             35  13    1             |
|      {--, --, -, 0, 0, 0}, {---, -, - -, 0, 0, 0}, {--, --, - -, 0, 0, 0}}  |
|        8   8  4              20  4    2              8   8    4             |
|                                                                             |
|o22 : List                                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

With no optional arguments, this function returns all regular triangulations,
not all triangulations!

See also
========

  * topcomNumTriangulations(Matrix),
    -- the number of triangulations of a point or vector configuration
  * topcomIsTriangulation, --
    determine if a set of subsets is a triangulation of a point set
  * topcomIsRegularTriangulation, --
    determine if a given triangulation is a regular triangulation
  * topcomRegularTriangulationWeights
    -- find a list of
    heights of a regular triangulation
  * topcomNumTriangulations -- the
    number of triangulations of a point or vector configuration

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

  * topcomAllTriangulations(Matrix),
    -- generate all triangulations of a point or vector configuration

topcomFlips(Matrix,List) -- find the neighboring triangulations (bistellar flips) of a triangulation
****************************************************************************************************

Synopsis
========

  * Function: topcomFlips,
  * Usage:
        topcomFlips(A, tri)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * tri, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
      * RegularOnly => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a list (Macaulay2Doc),

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

+-----------------------------------------------------------------------------+
|i1 : A = transpose matrix {                                                  |
|         {-1, -1, -1, 0}, {-1, -1, 0, -1}, {-1, -1,                          |
|         {-1, 0, -1, 2}, {-1, 0, 0, -1}, {0, -1, 1,                          |
|         {1, 1, 1, -1}, {-1, 0, -1, 0}, {-1, 0, -1,                          |
|                                                                             |
|o1 = | -1 -1 -1 -1 -1 -1 0  1  1  -1 -1 0  0 |                               |
|     | -1 -1 -1 0  0  0  -1 1  1  0  0  0  0 |                               |
|     | -1 0  0  -1 -1 0  1  -1 1  -1 -1 -1 0 |                               |
|     | 0  -1 0  -1 2  -1 -1 2  -1 0  1  1  0 |                               |
|                                                                             |
|              4        13                                                    |
|o1 : Matrix ZZ  <--- ZZ                                                      |
|-----------------------------------------------------------------------------|
|0, 0}, {-1, 0, -1, -1},                                                      |
|-1}, {1, 1, -1, 2},                                                          |
|1}, {0, 0, -1, 1}, {0,0,0,0}}                                                |
+-----------------------------------------------------------------------------+
|i2 : tri1 = topcomRegularFineTriangulation A                                 |
|                                                                             |
|o2 = {{0, 1, 2, 3, 6}, {1, 2, 3, 5, 6}, {0, 2, 3, 6, 9}, {2, 3, 5, 6, 9}, {0,|
|     ------------------------------------------------------------------------|
|     2, 6, 9, 10}, {2, 5, 6, 9, 10}, {0, 2, 4, 6, 10}, {2, 4, 5, 6, 10}, {0, |
|     ------------------------------------------------------------------------|
|     3, 6, 9, 11}, {3, 6, 7, 9, 11}, {6, 7, 9, 10, 11}, {4, 6, 7, 10, 11},   |
|     ------------------------------------------------------------------------|
|     {0, 6, 9, 10, 11}, {0, 4, 6, 10, 11}, {3, 6, 7, 9, 12}, {6, 7, 9, 10,   |
|     ------------------------------------------------------------------------|
|     12}, {4, 6, 7, 10, 12}, {4, 6, 7, 8, 12}, {3, 6, 7, 8, 12}, {3, 5, 7, 9,|
|     ------------------------------------------------------------------------|
|     12}, {5, 7, 9, 10, 12}, {4, 5, 7, 10, 12}, {4, 5, 7, 8, 12}, {3, 5, 7,  |
|     ------------------------------------------------------------------------|
|     8, 12}, {3, 5, 6, 9, 12}, {5, 6, 9, 10, 12}, {4, 5, 6, 10, 12}, {4, 5,  |
|     ------------------------------------------------------------------------|
|     6, 8, 12}, {3, 5, 6, 8, 12}}                                            |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : topcomFlips(A, tri1)                                                    |
|                                                                             |
|o3 = {{{0, 5}, {2, 3}}, {{0, 7}, {11}}, {{1, 9}, {2, 3}}, {{2, 11}, {0, 4,   |
|     ------------------------------------------------------------------------|
|     6}}, {{3, 10}, {9}}, {{4, 9}, {10}}, {{5, 6, 7}, {12}}, {{8, 9}, {3, 5, |
|     ------------------------------------------------------------------------|
|     7}}, {{8, 10}, {4, 5, 7}}, {{11, 12}, {6, 7, 9}}}                       |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * topcomNumFlips(Matrix,List), --
    find the number of neighboring triangulations (bistellar flips) of a
    triangulation

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

  * topcomFlips(Matrix,List) -- find the
    neighboring triangulations (bistellar flips) of a triangulation

topcomIsRegularTriangulation -- determine if a given triangulation is a regular triangulation
*********************************************************************************************

Synopsis
========

  * Usage:
        topcomIsRegularTriangulation(A, tri)
  * Inputs:
      * A, a matrix (Macaulay2Doc), A $d \times n$ matrix over
        ZZ.  Each column represents one of the points which can be used in a
        triangulation
      * tri, a list (Macaulay2Doc), A triangulation of the point
        set C
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true, If true, $A$ determines a point configuration, and the
        matrix is then "homogenized": a row of 1's is appended to $A$, creating
        a vector configuration of $n$ vectors in $\mathbb{R}^{d+1}$.
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether the given
        triangulation is regular

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

The following example is one of the simplest examples of a non-regular
triangulation.  Notice that tri is a triangulation of the polytope which is the
convex hull of the columns of $A$, which are the only points allowed in the
triangulation.

+-----------------------------------------------------------------------------+
|i1 : A = transpose matrix {{0,3},{0,1},{-1,-1},{1,-1},{-4,-2},{4,-2}}        |
|                                                                             |
|o1 = | 0 0 -1 1  -4 4  |                                                     |
|     | 3 1 -1 -1 -2 -2 |                                                     |
|                                                                             |
|              2        6                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i2 : tri = {{0,1,2}, {1,3,5}, {2,3,4}, {0,1,5},                              |
|         {0,2,4}, {3,4,5}, {1,2,3}}                                          |
|                                                                             |
|o2 = {{0, 1, 2}, {1, 3, 5}, {2, 3, 4}, {0, 1, 5}, {0, 2, 4}, {3, 4, 5}, {1,  |
|     ------------------------------------------------------------------------|
|     2, 3}}                                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : topcomIsRegularTriangulation(A,tri)                                     |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+
|i4 : assert not topcomIsRegularTriangulation(A,tri)                          |
+-----------------------------------------------------------------------------+
|i5 : assert topcomIsTriangulation(A, tri)                                    |
+-----------------------------------------------------------------------------+

Setting debugLevel to either 1,2, or 5 will give more detail about what files
are written to Topcom, and what the executable is. Setting debugLevel to 0
means that the function will run silently.

Caveat
======

Do we check that the triangulation is actually well defined?

See also
========

  * topcomRegularFineTriangulation
    -- compute a regular
    triangulation using all of the given points
  * topcomIsTriangulation, --
    determine if a set of subsets is a triangulation of a point set

Ways to use topcomIsRegularTriangulation :
==========================================

  * "topcomIsRegularTriangulation(Matrix,List)"

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

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

topcomIsTriangulation(Matrix,List) -- determine if a set of subsets is a triangulation of a point set
*****************************************************************************************************

Synopsis
========

  * Function: topcomIsTriangulation,
  * Usage:
        topcomIsTriangulation(A, tri)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * tri, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

Caveat
======

topcom doesn't check that the subsets given are simplices, so we do that
directly.

See also
========

  * topcomIsRegularTriangulation(Matrix,List)
    -- determine if a given triangulation is a
    regular triangulation

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

  * topcomIsTriangulation(Matrix,List)
    -- determine if a set of subsets
    is a triangulation of a point set

topcomNumFlips(Matrix,List) -- find the number of neighboring triangulations (bistellar flips) of a triangulation
*****************************************************************************************************************

Synopsis
========

  * Function: topcomNumFlips,
  * Usage:
        topcomNumFlips(A, tri)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * tri, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
      * RegularOnly => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * an integer (Macaulay2Doc),

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

See also
========

  * topcomNumFlips(Matrix,List), --
    find the number of neighboring triangulations (bistellar flips) of a
    triangulation

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

  * topcomNumFlips(Matrix,List), --
    find the number of neighboring triangulations (bistellar flips) of a
    triangulation

topcomNumTriangulations(Matrix) -- the number of triangulations of a point or vector configuration
**************************************************************************************************

Synopsis
========

  * Function: topcomNumTriangulations,
  * Usage:
        topcomNumTriangulations A
        topcomNumTriangulations(A, Homogenize => true, Fine => true, RegularOnly => true)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
      * ConnectedToRegular => a Boolean value (Macaulay2Doc),
        default value true
      * Fine => a Boolean value (Macaulay2Doc), default value
        false
      * RegularOnly => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * an integer (Macaulay2Doc),

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

This function is identical in function to
topcomAllTriangulations(Matrix),
(including optional arguments), but instead just counts the number, rather than
enumerate them.

For example, to use the same example as in
topcomAllTriangulations(Matrix),:

+---------------------------------------------------------------------+
|i1 : A = transpose matrix {{0,3},{0,1},{-1,-1},{1,-1},{-4,-2},{4,-2}}|
|                                                                     |
|o1 = | 0 0 -1 1  -4 4  |                                             |
|     | 3 1 -1 -1 -2 -2 |                                             |
|                                                                     |
|              2        6                                             |
|o1 : Matrix ZZ  <--- ZZ                                              |
+---------------------------------------------------------------------+
|i2 : topcomNumTriangulations A == 16                                 |
|                                                                     |
|o2 = true                                                            |
+---------------------------------------------------------------------+
|i3 : topcomNumTriangulations A == # topcomAllTriangulations A        |
|                                                                     |
|o3 = true                                                            |
+---------------------------------------------------------------------+

Similarly, one can count the number of triangulations with different properties
using the optional arguments.

+-----------------------------------------------------------------------------+
|i4 : topcomNumTriangulations(A, RegularOnly => false)                        |
|                                                                             |
|o4 = 18                                                                      |
+-----------------------------------------------------------------------------+
|i5 : assert(topcomNumTriangulations(A, RegularOnly => false) == 18)          |
+-----------------------------------------------------------------------------+
|i6 : assert(topcomNumTriangulations(A, RegularOnly => false) == #            |
|-----------------------------------------------------------------------------|
|topcomAllTriangulations(A, RegularOnly => false))                            |
+-----------------------------------------------------------------------------+

See also
========

  * topcomAllTriangulations(Matrix),
    -- generate all triangulations of a point or vector configuration

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

  * topcomNumTriangulations(Matrix),
    -- the number of triangulations of a point or vector configuration

topcomRegularFineTriangulation(Matrix) -- compute a regular triangulation using all of the given points
*******************************************************************************************************

Synopsis
========

  * Function: topcomRegularFineTriangulation,
  * Usage:
        topcomRegularFineTriangulation A
  * Inputs:
      * A, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a list (Macaulay2Doc),

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

This function returns a regular fine triangulation of the point set $A$ (that
is, a list of lists of indices in the range $0, \ldots, n-1$, where $A$ is $d
\times n$, and has full rank.

Recall: a fine triangulation is one which uses all of the points, and a regular
triangulation is one which is induced as the lower faces of a lift of the
points to one dimension higher.

Here we find a regular fine triangulation of the cyclic polytope with 7
vertices in 3-space.

+-----------------------------------------------------------------------------+
|i1 : A = matrix {{0, 1, 2, 3, 4, 5, 6}, {0, 1, 4, 9, 16, 25, 36}, {0, 1, 8,  |
|                                                                             |
|o1 = | 0 1 2 3  4  5   6   |                                                 |
|     | 0 1 4 9  16 25  36  |                                                 |
|     | 0 1 8 27 64 125 216 |                                                 |
|                                                                             |
|              3        7                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
|-----------------------------------------------------------------------------|
|27, 64, 125, 216}}                                                           |
+-----------------------------------------------------------------------------+
|i2 : tri = topcomRegularFineTriangulation A                                  |
|                                                                             |
|o2 = {{0, 1, 2, 3}, {1, 2, 3, 4}, {0, 1, 3, 4}, {2, 3, 4, 5}, {1, 2, 4, 5},  |
|     ------------------------------------------------------------------------|
|     {0, 1, 4, 5}, {3, 4, 5, 6}, {2, 3, 5, 6}, {1, 2, 5, 6}, {0, 1, 5, 6}}   |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : assert topcomIsTriangulation(A, tri)                                    |
+-----------------------------------------------------------------------------+
|i4 : assert topcomIsRegularTriangulation(A, tri)                             |
+-----------------------------------------------------------------------------+
|i5 : topcomRegularTriangulationWeights(A, tri)                               |
|                                                                             |
|      5  5  1                                                                |
|o5 = {-, -, -, 0, 0, 0, 0}                                                   |
|      2  6  6                                                                |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * topcomIsTriangulation, --
    determine if a set of subsets is a triangulation of a point set
  * topcomRegularTriangulationWeights
    -- find a list of
    heights of a regular triangulation
  * convexHull (Polyhedra) -- computing the convex hull of
    points, rays and polyhedra

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

  * topcomRegularFineTriangulation(Matrix)
    -- compute a regular
    triangulation using all of the given points

topcomRegularTriangulationWeights(Matrix,List) -- find a list of heights of a regular triangulation
***************************************************************************************************

Synopsis
========

  * Function: topcomRegularTriangulationWeights,
  * Usage:
        topcomRegularTriangulationWeights(A, tri)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * tri, a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Homogenize => a Boolean value (Macaulay2Doc), default
        value true
  * Outputs:
      * a list (Macaulay2Doc),

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

If the given triangulation is regular, this returns the corresponding list of
weights. If we lift each point to this height (hieights can be negative too),
then the lower convex hull of these lifted points is the given triangulation.
This can be checked via the routine regularSubdivision (Polyhedra),
in the package Polyhedra.

+-----------------------------------------------------------------------------+
|i1 : A = matrix {                                                            |
|         {0, -1, 2, 3, 4, -5, 6},                                            |
|         {0, 1, -4, 9, 16, 25, 36},                                          |
|         {0, 1, 8, -27, 64, 125, -216}}                                      |
|                                                                             |
|o1 = | 0 -1 2  3   4  -5  6    |                                             |
|     | 0 1  -4 9   16 25  36   |                                             |
|     | 0 1  8  -27 64 125 -216 |                                             |
|                                                                             |
|              3        7                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i2 : Ts = topcomAllTriangulations A;                                         |
+-----------------------------------------------------------------------------+
|i3 : #Ts == 25                                                               |
|                                                                             |
|o3 = true                                                                    |
+-----------------------------------------------------------------------------+
|i4 : netList Ts                                                              |
|                                                                             |
|     +------------+------------+------------+------------+------------+------|
|o4 = |{0, 1, 2, 3}|{0, 1, 3, 6}|{0, 2, 3, 6}|{1, 2, 3, 4}|{1, 2, 4, 5}|{1, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 3, 4}|{1, 2, 3, 6}|{1, 2, 4, 5}|{1, 3, 4, 5}|{1, 3, 5, 6}|{2, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 3}|{0, 1, 3, 6}|{0, 2, 3, 6}|{1, 2, 3, 4}|{1, 2, 4, 5}|{1, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 4}|{0, 1, 3, 4}|{0, 1, 3, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{1, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 3}|{0, 1, 3, 6}|{0, 2, 3, 6}|{1, 2, 3, 5}|{1, 3, 5, 6}|{2, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 3, 5}|{1, 2, 3, 6}|{1, 3, 5, 6}|{2, 3, 4, 5}|{2, 3, 4, 6}|{3, 4,|
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 3, 4}|{1, 2, 3, 6}|{1, 2, 4, 5}|{1, 3, 4, 6}|{1, 4, 5, 6}|{2, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 3, 5}|{0, 1, 3, 6}|{0, 2, 3, 5}|{0, 2, 3, 6}|{1, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 4}|{0, 1, 3, 4}|{0, 1, 3, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{1, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 3, 4}|{0, 1, 3, 6}|{0, 1, 4, 5}|{0, 2, 3, 4}|{0, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 4}|{0, 1, 4, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{0, 3, 4, 6}|{1, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 3, 4}|{0, 1, 3, 6}|{0, 1, 4, 5}|{0, 2, 3, 4}|{0, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 3, 5}|{0, 1, 3, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{0, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 3, 5}|{0, 2, 3, 6}|{0, 3, 5, 6}|{2, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 4, 5}|{1, 2, 4, 6}|{1, 4, 5, 6}|            |            |      |
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 5, 6}|{2, 3, 4, 5}|{2, 3, 4, 6}|{2, 3, 5, 6}|{3, 4, 5, 6}|      |
|     +------------+------------+------------+------------+------------+------|
|     |{1, 2, 5, 6}|{2, 4, 5, 6}|            |            |            |      |
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 4}|{0, 1, 4, 6}|{0, 2, 4, 6}|{1, 2, 4, 5}|{1, 4, 5, 6}|      |
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 5, 6}|{2, 3, 4, 5}|{2, 3, 4, 6}|{2, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{0, 2, 4, 5}|{0, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 4, 5}|{0, 1, 4, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{0, 2,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 5, 6}|{2, 4, 5, 6}|            |      |
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 4, 5}|{0, 1, 4, 6}|{0, 2, 4, 5}|{0, 2, 4, 6}|{1, 4,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 3, 4}|{0, 2, 3, 6}|{0, 2, 4, 5}|{0, 3,|
|     +------------+------------+------------+------------+------------+------|
|     |{0, 1, 2, 5}|{0, 1, 5, 6}|{0, 2, 4, 5}|{0, 2, 4, 6}|{0, 4, 5, 6}|      |
|     +------------+------------+------------+------------+------------+------|
|-----------------------------------------------------------------------------|
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{1, 3, 5, 6}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 6}|{3, 4, 5, 6}|            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 6}|{1, 4, 5, 6}|{2, 3, 4, 6}|            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{1, 3, 4, 5}|{1, 3, 5, 6}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 5, 6}|            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 6}|            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 5, 6}|{2, 3, 4, 5}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{1, 3, 4, 6}|{1, 4, 5, 6}|{2, 3, 4, 6}|            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 3, 6}|{0, 2, 4, 5}|{1, 3, 4, 5}|{1, 3, 5, 6}|{2, 3, 4, 6}|{3, 4, 5, 6}|     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{1, 4, 5, 6}|{2, 3, 4, 6}|            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 3, 6}|{0, 2, 4, 5}|{1, 3, 4, 6}|{1, 4, 5, 6}|{2, 3, 4, 6}|            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{0, 3, 4, 5}|{1, 3, 5, 6}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 5, 6}|{3, 4, 5, 6}|            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{0, 3, 5, 6}|{2, 3, 4, 6}|{3, 4, 5, 6}|            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 5}|{0, 3, 4, 6}|{1, 4, 5, 6}|{2, 3, 4, 6}|            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 5, 6}|            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
| 4, 6}|{0, 4, 5, 6}|{2, 3, 4, 6}|            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
|      |            |            |            |            |            |     |
|------+------------+------------+------------+------------+------------+     |
+-----------------------------------------------------------------------------+
|i5 : Ts/(tri -> topcomIsRegularTriangulation(A, tri))                        |
|                                                                             |
|o5 = {true, true, true, true, true, true, true, true, true, true, true, true,|
|     ------------------------------------------------------------------------|
|     true, true, true, true, true, true, true, true, true, true, true, true, |
|     ------------------------------------------------------------------------|
|     true}                                                                   |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : weights = topcomRegularTriangulationWeights(A, Ts#0)                    |
|                                                                             |
|       24235    77731    17659                                               |
|o6 = {-------, -------, ------, 0, 0, 0, 0}                                  |
|      1467081  5029992  838332                                               |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : needsPackage "Polyhedra"                                                |
|                                                                             |
|o7 = Polyhedra                                                               |
|                                                                             |
|o7 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i8 : Ts#0                                                                    |
|                                                                             |
|o8 = {{0, 1, 2, 3}, {0, 1, 3, 6}, {0, 2, 3, 6}, {1, 2, 3, 4}, {1, 2, 4, 5},  |
|     ------------------------------------------------------------------------|
|     {1, 3, 4, 5}, {1, 3, 5, 6}, {2, 3, 4, 6}, {3, 4, 5, 6}}                 |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : tri0 = regularSubdivision(A, matrix{weights})                           |
|                                                                             |
|o9 = {{0, 1, 2, 3}, {0, 1, 3, 6}, {0, 2, 3, 6}, {1, 2, 3, 4}, {1, 2, 4, 5},  |
|     ------------------------------------------------------------------------|
|     {1, 3, 4, 5}, {1, 3, 5, 6}, {2, 3, 4, 6}, {3, 4, 5, 6}}                 |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : tri0 = tri0//sort/sort                                                 |
|                                                                             |
|o10 = {{0, 1, 2, 3}, {0, 1, 3, 6}, {0, 2, 3, 6}, {1, 2, 3, 4}, {1, 2, 4, 5}, |
|      -----------------------------------------------------------------------|
|      {1, 3, 4, 5}, {1, 3, 5, 6}, {2, 3, 4, 6}, {3, 4, 5, 6}}                |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : assert(tri0 == Ts#0)                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * topcomIsRegularTriangulation(Matrix,List)
    -- determine if a given triangulation is a
    regular triangulation
  * regularSubdivision (Polyhedra) -- Computes the
    regular cell decomposition

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

  * topcomRegularTriangulationWeights(Matrix,List)
    -- find a list of
    heights of a regular triangulation