triangulation -- make a Triangulation object

Usage:

triangulation(A, T)

triangulation(vecs, T)
Inputs:
- A, a matrix, whose columns are the points or vectors of the configuration
- vecs, a list, a list of points or vectors (each entry a list of integers or rationals); equivalent to passing transpose matrix vecs
- T, a list, representing a triangulation of the columns of $A$ (each element in the list is a list of indices in the range $0, \ldots, n-1$, where $n$ is the number of columns of $A$)
Optional inputs:
- Homogenize => a Boolean value, default value null, controls how $A$ is interpreted. By default (null) the interpretation is inferred from the size of the max simplices in $T$ (see Description below). Pass true to force a point-set interpretation (a row of $1$'s is appended to $A$ before storing) or false to force a vector-configuration interpretation (matrix stored as-is). An explicit value inconsistent with the simplex sizes is an error.
Outputs:
- an instance of the type Triangulation, A Triangulation object. Very little computation is performed. The matrix and list representing a triangulation is packaged into an object to make clear that it is a triangulation

Description

The Homogenize option determines how $A$ is interpreted, not just how it is stored. By default the constructor inspects the size of the max simplices in $T$:

$\bullet$ if every max simplex has size numRows A + 1, $A$ is treated as a point set and the stored matrix is $A$ with an appended row of $1$'s (homogenisation);

$\bullet$ if every max simplex has size numRows A, $A$ is already a vector configuration (e.g., a $d \times n$ matrix of rays in $\RR^d$) and is stored as given.

Downstream routines (regularity, flips, chirotope, $\ldots$) read the ambient dimension from the stored matrix, so the two interpretations yield genuinely different triangulations of the same combinatorial $T$. Passing Homogenize => true or false forces a particular interpretation; an explicit value inconsistent with the inferred one is rejected.

i1 : P = hypercube 3

o1 = P

o1 : Polyhedron

i2 : A = vertices P

o2 = | -1 1  -1 1  -1 1  -1 1 |
     | -1 -1 1  1  -1 -1 1  1 |
     | -1 -1 -1 -1 1  1  1  1 |

              3       8
o2 : Matrix QQ  <-- QQ

i3 : T = topcomRegularFineTriangulation A

o3 = {{0, 1, 2, 4}, {1, 2, 3, 4}, {1, 3, 4, 5}, {2, 3, 4, 6}, {3, 4, 5, 6},
     ------------------------------------------------------------------------
     {3, 5, 6, 7}}

o3 : List

i4 : tri = triangulation(A, T)

o4 = triangulation {{0, 1, 2, 4}, {1, 2, 3, 4}, {1, 3, 4, 5}, {2, 3, 4, 6}, {3, 4, 5, 6}, {3, 5, 6, 7}}

o4 : Triangulation

i5 : matrix tri

o5 = | -1 1  -1 1  -1 1  -1 1 |
     | -1 -1 1  1  -1 -1 1  1 |
     | -1 -1 -1 -1 1  1  1  1 |
     | 1  1  1  1  1  1  1  1 |

              4       8
o5 : Matrix QQ  <-- QQ

i6 : vectors tri

o6 = {{-1, -1, -1, 1}, {1, -1, -1, 1}, {-1, 1, -1, 1}, {1, 1, -1, 1}, {-1,
     ------------------------------------------------------------------------
     -1, 1, 1}, {1, -1, 1, 1}, {-1, 1, 1, 1}, {1, 1, 1, 1}}

o6 : List

i7 : max tri

o7 = {{0, 1, 2, 4}, {1, 2, 3, 4}, {1, 3, 4, 5}, {2, 3, 4, 6}, {3, 4, 5, 6},
     ------------------------------------------------------------------------
     {3, 5, 6, 7}}

o7 : List

i8 : isWellDefined tri

o8 = true

i9 : netList flipCandidates tri

     +------+------+
o9 = |{1, 2}|{0, 3}|
     +------+------+
     |{3, 4}|{2, 5}|
     +------+------+
     |{3, 4}|{1, 6}|
     +------+------+
     |{5, 6}|{4, 7}|
     +------+------+

i10 : isFine tri

o10 = true

i11 : isStar tri

o11 = false

i12 : isRegularTriangulation tri

o12 = true

A vector configuration: simplex size matches the row count of $A$, so no homogenisation is applied.

i13 : V = transpose matrix {{1,1,1,1},{0,1,1,1},{1,0,1,1},{1,1,0,1},{0,0,1,1},{0,1,0,1},{1,0,0,1},{0,0,0,1}}

o13 = | 1 0 1 1 0 0 1 0 |
      | 1 1 0 1 0 1 0 0 |
      | 1 1 1 0 1 0 0 0 |
      | 1 1 1 1 1 1 1 1 |

               4       8
o13 : Matrix ZZ  <-- ZZ

i14 : triV = {{0,1,2,3},{1,2,3,4},{1,3,4,5},{2,3,4,6},{3,4,5,6},{4,5,6,7}}

o14 = {{0, 1, 2, 3}, {1, 2, 3, 4}, {1, 3, 4, 5}, {2, 3, 4, 6}, {3, 4, 5, 6},
      -----------------------------------------------------------------------
      {4, 5, 6, 7}}

o14 : List

i15 : Tv = triangulation(V, triV)

o15 = triangulation {{0, 1, 2, 3}, {1, 2, 3, 4}, {1, 3, 4, 5}, {2, 3, 4, 6}, {3, 4, 5, 6}, {4, 5, 6, 7}}

o15 : Triangulation

i16 : matrix Tv

o16 = | 1 0 1 1 0 0 1 0 |
      | 1 1 0 1 0 1 0 0 |
      | 1 1 1 0 1 0 0 0 |
      | 1 1 1 1 1 1 1 1 |

               4       8
o16 : Matrix ZZ  <-- ZZ

The (List, List) form is convenient when the configuration is given as a list of vectors:

i17 : triangulation({{0,0},{1,0},{0,1},{1,1}}, {{0,1,2},{1,2,3}})

o17 = triangulation {{0, 1, 2}, {1, 2, 3}}

o17 : Triangulation

Caveat

Ways to use triangulation:

triangulation(List,List)
triangulation(Matrix,List)

For the programmer

The object triangulation is a method function with options.

The source of this document is in /build/reproducible-path/macaulay2-1.26.06+ds/M2/Macaulay2/packages/Triangulations.m2:1276:0.

triangulation -- make a Triangulation object

Description

Caveat

See also

Ways to use triangulation:

For the programmer