Navigation

Example:

To create the bipyramid over a square and keep the vertex labels, do this:> $p = lattice_bipyramid(cube(2),new Vector(1,0,0),relabel=>1);> print $p->VERTICES; 1 -1 -1 0 1 1 -1 0 1 -1 1 0 1 1 1 0 1 0 0 1 1 0 0 -1> print $p->VERTEX_LABELS; 0 1 2 3 Apex Apex'

lattice_pyramid (P, z, v) → Polytope
Make a lattice pyramid over a polyhedron. The pyramid is the convex hull of the input polyhedron P and a point v outside the affine span of P.
Parameters
Polytope P
Rational z
the height for the apex (v,z), default value is 1.
Vector v
the lattice point to use as apex, default is the first vertex of P.
Options
Bool relabel
copy the original vertex labels, label the new top vertex with "Apex".
Returns
Polytope
Example:
To create the pyramid of height 5 over a square and keep the vertex labels, do this:> $p = lattice_pyramid(cube(2),5,new Vector(1,0,0),relabel=>1);> print $p->VERTICES; 1 -1 -1 0 1 1 -1 0 1 -1 1 0 1 1 1 0 1 0 0 5> print $p->VERTEX_LABELS; 0 1 2 3 Apex
lawrence (P) → Cone

Create the Lawrence polytope Lambda(P) corresponding to P. Lambda(P) has the property that Gale(Lambda(P)) = Gale(P) union -Gale(P).
Parameters
Cone P
an input cone or polytope
Returns
Cone
the Lawrence cone or polytope to P
make_totally_dual_integral (P) → Polytope

Produces a polyhedron with an totally dual integral inequality formulation of a full dimensional polyhedron
Parameters
Polytope P
Returns
Polytope
mapping_polytope (P1, P2) → Polytope

Construct a new polytope as the mapping polytope of two polytopes P1 and P2. The mapping polytope is the set of all affine maps from R^p to R^q, that map P1 into P2.
The label of a new facet corresponding to v₁ and h₁ will have the form "v₁*h₁".
Parameters
Polytope P1
Polytope P2
Options
Bool relabel
Returns
Polytope
minkowski_sum (P1, P2) → Polytope
Produces the Minkowski sum of P1 and P2.
Parameters
Polytope P1
Polytope P2
Returns
Polytope
Example:
The following stores the minkowski sum of a square and a triangle in the variable $p and then prints its vertices.> $p = minkowski_sum(cube(2),simplex(2));> print $p->VERTICES; 1 -1 -1 1 2 -1 1 -1 2 1 2 1 1 1 2
minkowski_sum (lambda, P1, mu, P2) → Polytope
Produces the polytope lambda*P1+mu*P2, where * and + are scalar multiplication and Minkowski addition, respectively.
Parameters
Scalar lambda
Polytope P1
Scalar mu
Polytope P2
Returns
Polytope
Example:
The following stores the minkowski sum of a scaled square and a triangle in the variable $p and then prints its vertices.> $p = minkowski_sum(2,cube(2),1,simplex(2));> print $p->VERTICES; 1 -2 -2 1 3 -2 1 -2 3 1 3 2 1 2 3
minkowski_sum_fukuda (summands) → Polytope<Scalar>
Computes the (VERTICES of the) Minkowski sum of a list of polytopes using the algorithm by Fukuda described in
Komei Fukuda, From the zonotope construction to the Minkowski addition of convex polytopes, J. Symbolic Comput., 38(4):1261-1272, 2004.
Parameters
Array<Polytope<Scalar>> summands
Returns
Polytope<Scalar>
Example:
> $p = minkowski_sum_fukuda([cube(2),simplex(2),cross(2)]);> print $p->VERTICES; 1 -2 -1 1 -1 -2 1 3 -1 1 3 1 1 2 -2 1 -2 2 1 -1 3 1 1 3
mixed_integer_hull (P, int_coords) → Polytope

Produces the mixed integer hull of a polyhedron
Parameters
Polytope P
Array<Int> int_coords
the coordinates to be integral;
Returns
Polytope
pointed_part (P) → Polytope
Produces the pointed part of a polyhedron
Parameters
Polytope P
Returns
Polytope
Example:
> $p = new Polytope(POINTS=>[[1,0,0],[1,0,1],[1,1,0],[1,1,1],[0,1,0],[0,0,1]]);> $pp = pointed_part($p);> print $pp->VERTICES; 1 0 0 0 1 0 0 0 1

prism (P, z1, z2) → Polytope

Make a prism over a pointed polyhedron. The prism is the product of the input polytope P and the interval [z1, z2].

Parameters

Polytope	P	the input polytope
Scalar	z1	the left endpoint of the interval; default value: -1
Scalar	z2	the right endpoint of the interval; default value: -z1

Options

Bool	no_coordinates	only combinatorial information is handled
Bool	relabel	creates an additional section VERTEX_LABELS; the bottom facet vertices get the labels from the original polytope; the labels of their clones in the top facet get a tick (') appended.

Returns

Example:

The following saves the prism over the square and the interval [-2,2] to the variable $p while relabeling, and then prints a nice representation of its vertices.> $p = prism(cube(2),-2,relabel=>1);> print labeled($p->VERTICES,$p->VERTEX_LABELS); 0:1 -1 -1 -2 1:1 1 -1 -2 2:1 -1 1 -2 3:1 1 1 -2 0':1 -1 -1 2 1':1 1 -1 2 2':1 -1 1 2 3':1 1 1 2

product (P1, P2) → Polytope

Construct a new polytope as the product of two given polytopes P1 and P2.

Parameters

Polytope	P1
Polytope	P2

Options

Bool	no_coordinates	only combinatorial information is handled
Bool	relabel	creates an additional section VERTEX_LABELS; the label of a new vertex corresponding to v₁ ⊕ v₂ will have the form LABEL_1*LABEL_2.

Returns

Example:

The following builds the product of a square and an interval while relabeling, and then prints a nice representation of its vertices.> $p = product(cube(2),cube(1),relabel=>1);> print labeled($p->VERTICES,$p->VERTEX_LABELS); 0*0:1 -1 -1 -1 0*1:1 -1 -1 1 1*0:1 1 -1 -1 1*1:1 1 -1 1 2*0:1 -1 1 -1 2*1:1 -1 1 1 3*0:1 1 1 -1 3*1:1 1 1 1

projection (P, indices) → Cone
Orthogonally project a pointed polyhedron to a coordinate subspace.
The subspace the polyhedron P is projected on is given by indices in the set indices. The option revert inverts the coordinate list. The client scans for all coordinate sections and produces proper output from each. If a description in terms of inequalities is found, the client performs Fourier-Motzkin elimination unless the nofm option is set. Setting the nofm option is useful if the corank of the projection is large; in this case the number of inequalities produced grows quickly.
Parameters
Cone P
Array<Int> indices
Options
Bool revert
inverts the coordinate list
Bool nofm
suppresses Fourier-Motzkin elimination
Returns
Cone
Example:
project the 3-cube along the first coordinate, i.e. to the subspace spanned by the second and third coordinate:> $p = projection(cube(3),[1],revert=>1);> print $p->VERTICES; 1 1 -1 1 1 1 1 -1 1 1 -1 -1
projection_full (P) → Cone

Orthogonally project a polyhedron to a coordinate subspace such that redundant columns are omitted, i.e., the projection becomes full-dimensional without changing the combinatorial type. The client scans for all coordinate sections and produces proper output from each. If a description in terms of inequalities is found, the client performs Fourier-Motzkin elimination unless the nofm option is set. Setting the nofm option is useful if the corank of the projection is large; in this case the number of inequalities produced grows quickly.
Parameters
Cone P
Options
Bool nofm
suppresses Fourier-Motzkin elimination
Bool relabel
copy labels to projection
Returns
Cone
pyramid (P, z) → Polytope
Make a pyramid over a polyhedron. The pyramid is the convex hull of the input polyhedron P and a point v outside the affine span of P. For bounded polyhedra, the projection of v to the affine span of P coincides with the vertex barycenter of P.
Parameters
Polytope P
Scalar z
is the distance between the vertex barycenter and v, default value is 1.
Options
Bool no_coordinates
don't compute new coordinates, produce purely combinatorial description.
Bool relabel
copy vertex labels from the original polytope, label the new top vertex with "Apex".
Returns
Polytope
Example:
The following saves the pyramid of height 2 over the square to the variable $p. The vertices are relabeled.> $p = pyramid(cube(2),2,relabel=>1); To print the vertices and vertex labels of the newly generated pyramid, do this:> print $p->VERTICES; 1 -1 -1 0 1 1 -1 0 1 -1 1 0 1 1 1 0 1 0 0 2> print $p->VERTEX_LABELS; 0 1 2 3 Apex
rand_inner_points (P, n) → Polytope

Produce a polytope with n random points from the input polytope P. Each generated point is a convex linear combination of the input vertices with uniformly distributed random coefficients. Thus, the output points can't in general be expected to be distributed uniformly within the input polytope; cf. unirand for this. The polytope must be BOUNDED.
Parameters
Polytope P
the input polytope
Int n
the number of random points
Options
Int seed
controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
Returns
Polytope
rand_vert (V, n) → Matrix

Selects n random vertices from the set of vertices V. This can be used to produce random polytopes which are neither simple nor simplicial as follows: First produce a simple polytope (for instance at random, by using rand_sphere, rand, or unirand). Then use this client to choose among the vertices at random. Generalizes random 0/1-polytopes.
Parameters
Matrix V
the vertices of a polytope
Int n
the number of random points
Options
Int seed
controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
Returns
Matrix
spherize (P) → Polytope
Project all vertices of a polyhedron P on the unit sphere. P must be CENTERED and BOUNDED.
Parameters
Polytope P
Returns
Polytope
Example:
The following scales the 2-dimensional cross polytope by 23 and then projects it back onto the unit circle.> $p = scale(cross(2),23);> $s = spherize($p);> print $s->VERTICES; 1 1 0 1 -1 0 1 0 1 1 0 -1

stack (P, stack_facets) → Polytope

Stack a (simplicial or cubical) polytope over one or more of its facets.

For each facet of the polytope P specified in stack_facets, the barycenter of its vertices is lifted along the normal vector of the facet. In the simplicial case, this point is directly added to the vertex set, thus building a pyramid over the facet. In the cubical case, this pyramid is truncated by a hyperplane parallel to the original facet at its half height. This way, the property of being simplicial or cubical is preserved in both cases.

The option lift controls the exact coordinates of the new vertices. It should be a rational number between 0 and 1, which expresses the ratio of the distance between the new vertex and the stacked facet, to the maximal possible distance. When lift=0, the new vertex would lie on the original facet. lift=1 corresponds to the opposite extremal case, where the new vertex hit the hyperplane of some neighbor facet. As an additional restriction, the new vertex can't lie further from the facet as the vertex barycenter of the whole polytope. Alternatively, the option noc (no coordinates) can be specified to produce a pure combinatorial description of the resulting polytope.

Parameters

Polytope	P
Set<Int>	stack_facets	the facets to be stacked; A single facet to be stacked is specified by its number. Several facets can be passed in a Set or in an anonymous array of indices: [n1,n2,...] Special keyword All means that all factes are to be stacked.

Options

Rational	lift	controls the exact coordinates of the new vertices; rational number between 0 and 1; default value: 1/2
Bool	no_coordinates	produces a pure combinatorial description (in contrast to lift)
Bool	relabel	creates an additional section VERTEX_LABELS; New vertices get labels 'f(FACET_LABEL)' in the simplicial case, and 'f(FACET_LABEL)-NEIGHBOR_VERTEX_LABEL' in the cubical case.

Returns

Example:

To generate a cubical polytope by stacking all facets of the 3-cube to height 1/4, do this:> $p = stack(cube(3),All,lift=>1/4);

stellar_all_faces (P, d) → Polytope

Perform a stellar subdivision of all proper faces, starting with the facets.
Parameter d specifies the lowest dimension of the faces to be divided. It can also be negative, then treated as the co-dimension. Default is 1, that is, the edges of the polytope.
Parameters
Polytope P
, must be bounded
Int d
the lowest dimension of the faces to be divided; negative values: treated as the co-dimension; default value: 1.
Returns
Polytope
stellar_indep_faces (P, in_faces) → Polytope

Perform a stellar subdivision of the faces in_faces of a polyhedron P.
The faces must have the following property: The open vertex stars of any pair of faces must be disjoint.
Parameters
Polytope P
, must be bounded
Array<Set<Int>> in_faces
Returns
Polytope
tensor (P1, P2) → Polytope
Construct a new polytope as the convex hull of the tensor products of the vertices of two polytopes P1 and P2. Unbounded polyhedra are not allowed. Does depend on the vertex coordinates of the input.
Parameters
Polytope P1
Polytope P2
Returns
Polytope
Example:
The following creates the tensor product polytope of two squares and then prints its vertices.> $p = tensor(cube(2),cube(2));> print $p->VERTICES; 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 -1 1 1 1 -1 -1 -1 -1

truncation (P, trunc_vertices) → Polytope

Cut off one or more vertices of a polyhedron.

The exact location of the cutting hyperplane(s) can be controlled by the option cutoff, a rational number between 0 and 1. When cutoff=0, the hyperplane would go through the chosen vertex, thus cutting off nothing. When cutoff=1, the hyperplane touches the nearest neighbor vertex of a polyhedron.

Alternatively, the option no_coordinates can be specified to produce a pure combinatorial description of the resulting polytope, which corresponds to the cutoff factor 1/2.

Parameters

Polytope	P
Set<Int>	trunc_vertices	the vertex/vertices to be cut off; A single vertex to be cut off is specified by its number. Several vertices can be passed in a Set or in an anonymous array of indices: [n1,n2,...] Special keyword All means that all vertices are to be cut off.

Options

Scalar	cutoff	controls the exact location of the cutting hyperplane(s); rational number between 0 and 1; default value: 1/2
Bool	no_coordinates	produces a pure combinatorial description (in contrast to cutoff)
Bool	relabel	creates an additional section VERTEX_LABELS; New vertices get labels of the form 'LABEL1-LABEL2', where LABEL1 is the original label of the truncated vertex, and LABEL2 is the original label of its neighbor.

Returns

Example:

To truncate the second vertex of the square at 1/4, try this:> $p = truncation(cube(2),2,cutoff=>1/4);> print $p->VERTICES; 1 -1 -1 1 1 -1 1 1 1 1 -1 1/2 1 -1/2 1

unirand (P, n) → Polytope
Produce a polytope with n random points that are uniformly distributed within the given polytope P. P must be bounded and full-dimensional.
Parameters
Polytope P
Int n
the number of random points
Options
Bool boundary
forces the points to lie on the boundary of the given polytope
Int seed
controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
Returns
Polytope
Examples:
This produces a polytope as the convex hull of 5 random points in the square with the origin as its center and side length 2:> $p = unirand(cube(2),5);
This produces a polytope as the convex hull of 5 random points on the boundary of the square with the origin as its center and side length 2:> $p = unirand(cube(2),5,boundary=>1);

vertex_figure (p, n) → Polytope

Construct the vertex figure of the vertex n of a polyhedron. The vertex figure is dual to a facet of the dual polytope.

Parameters

Polytope	p
Int	n	number of the chosen vertex

Options

Scalar	cutoff	controls the exact location of the cutting hyperplane. It should lie between 0 and 1. Value 0 would let the hyperplane go through the chosen vertex, thus degenerating the vertex figure to a single point. Value 1 would let the hyperplane touch the nearest neighbor vertex of a polyhedron. Default value is 1/2.
Bool	no_coordinates	skip the coordinates computation, producing a pure combinatorial description.
Bool	relabel	inherit vertex labels from the corresponding neighbor vertices of the original polytope.

Returns

Example:

This produces a vertex figure of one vertex of a 3-dimensional cube with the origin as its center and side length 2. The result is a 2-simplex.> $p = vertex_figure(cube(3),5);> print $p->VERTICES; 1 1 -1 0 1 1 0 1

wedge (P, facet, z, z_prime) → Polytope

Make a wedge from a polytope over the given facet. The polytope must be bounded. The inclination of the bottom and top side facet is controlled by z and z_prime, which are heights of the projection of the old vertex barycenter on the bottom and top side facet respectively.

Parameters

Polytope	P	, must be bounded
Int	facet	the `cutting edge'.
Rational	z	default value is 0.
Rational	z_prime	default value is -z, or 1 if z==0.

Options

Bool	no_coordinates	don't compute coordinates, pure combinatorial description is produced.
Bool	relabel	create vertex labels: The bottom facet vertices obtain the labels from the original polytope; the labels of their clones in the top facet get a tick (') appended.

Returns

Example:

This produces the wedge from a square (over the facet 0), which yields a prism over a triangle:> $p = wedge(cube(2),0);> print $p->VERTICES; 1 -1 -1 0 1 1 -1 0 1 -1 1 0 1 1 1 0 1 1 -1 2 1 1 1 2

wreath (P1, P2) → Polytope

Construct a new polytope as the wreath product of two input polytopes P1, P2. P1 and P2 have to be BOUNDED.

Parameters

Polytope	P1
Polytope	P2

Options

Bool	dual	invokes the computation of the dual wreath product
Bool	relabel	creates an additional section VERTEX_LABELS; the label of a new vertex corresponding to v₁ ⊕ v₂ will have the form LABEL_1*LABEL_2.

Returns

Producing a polytope from scratch
With these clients you can create polytopes belonging to various parameterized families which occur frequently in polytope theory, as well as several kinds of random polytopes. Regular polytopes and their friends are listed separately.
- associahedron (d) → Polytope
  
  Produce a d-dimensional associahedron (or Stasheff polytope). We use the facet description given in Ziegler's book on polytopes, section 9.2.
  Parameters
  Int d
  the dimension
  Returns
  Polytope
- binary_markov_graph (observation) → PropagatedPolytope
  
  Defines a very simple graph for a polytope propagation related to a Hidden Markov Model. The propagated polytope is always a polygon. For a detailed description see
  M. Joswig: Polytope propagation, in: Algebraic statistics and computational biology
  by L. Pachter and B. Sturmfels (eds.), Cambridge, 2005.
  Parameters
  Array<Bool> observation
  Returns
  PropagatedPolytope
- binary_markov_graph (observation)
  
  Parameters
  String observation
  encoded as a string of "0" and "1".
- birkhoff (n, even) → Polytope
  
  Constructs the Birkhoff polytope of dimension n². It is the polytope of nxn stochastic matrices (encoded as n² row vectors), thus matrices with non-negative entries whose row and column entries sum up to one. Its vertices are the permutation matrices.
  Parameters
  Int n
  Bool even
  Defaults to '0'. Set this to '1' to get vertices only for even permutation matrices.
  Returns
  Polytope
- cyclic (d, n) → Polytope
  
  Produce a d-dimensional cyclic polytope with n points. Prototypical example of a neighborly polytope. Combinatorics completely known due to Gale's evenness criterion. Coordinates are chosen on the (spherical) moment curve at integer steps from start, or 0 if unspecified. If spherical is true the vertices lie on the sphere with center (1/2,0,...,0) and radius 1/2. In this case (the necessarily positive) parameter start defaults to 1.
  Parameters
  Int d
  the dimension
  Int n
  the number of points
  Options
  Int start
  defaults to 0 (or to 1 if spherical)
  Bool spherical
  defaults to false
  Returns
  Polytope
  
  Example:
  To create the 2-dimensional cyclic polytope with 6 points on the sphere, starting at 3:> $p = cyclic(2,6,start=>3,spherical=>1);> print $p->VERTICES; 1 1/10 3/10 1 1/26 5/26 1 1/37 6/37 1 1/50 7/50 1 1/65 8/65
- cyclic_caratheodory (d, n) → Polytope
  
  Produce a d-dimensional cyclic polytope with n points. Prototypical example of a neighborly polytope. Combinatorics completely known due to Gale's evenness criterion. Coordinates are chosen on the trigonometric moment curve. For cyclic polytopes from other curves, see polytope::cyclic.
  Parameters
  Int d
  the dimension. Required to be even.
  Int n
  the number of points
  Returns
  Polytope
- delpezzo (d, scale) → Polytope<Scalar>
  
  Produce a d-dimensional del-Pezzo polytope, which is the convex hull of the cross polytope together with the all-ones and minus all-ones vector.
  All coordinates are +/- scale or 0.
  Parameters
  Int d
  the dimension
  Scalar scale
  the absolute value of each non-zero vertex coordinate. Needs to be positive. The default value is 1.
  Returns
  Polytope<Scalar>
- dwarfed_cube (d) → Polytope
  
  Produce a d-dimensional dwarfed cube.
  Parameters
  Int d
  the dimension
  Returns
  Polytope
- dwarfed_product_polygons (d, s) → Polytope
  
  Produce a d-dimensional dwarfed product of polygons of size s.
  Parameters
  Int d
  the dimension
  Int s
  the size
  Returns
  Polytope
- explicit_zonotope (zones) → Polytope
  
  Produce the POINTS of a zonotope as the iterated Minkowski sum of all intervals [-x,x], where x ranges over the rows of the input matrix zones.
  Parameters
  Matrix zones
  the input vectors
  Options
  Bool rows_are_points
  the rows of the input matrix represent affine points(true, default) or linear vectors(false)
  Returns
  Polytope
  
  Example:
  > $M = new Matrix([1,1],[1,-1]);> $p = explicit_zonotope($M,rows_are_points=>0);> print $p->VERTICES; 1 2 0 1 0 -2 1 0 2 1 -2 0
- fano_simplex (d) → Polytope
  
  Produce a Fano d-simplex.
  Parameters
  Int d
  the dimension
  Options
  Bool group
  Returns
  Polytope
  
  Example:
  To create the 2-dimensional fano simplex and compute its symmetry group, type this: and print ints generators, do this:> fano_simplex(2,group=>1);> print $p->GROUP->GENERATORS; 1 0 2 2 0 1
- fractional_knapsack (b) → Polytope
  
  Produce a knapsack polytope defined by one linear inequality (and non-negativity constraints).
  Parameters
  Vector<Rational> b
  linear inequality
  Returns
  Polytope
- goldfarb (d, e, g) → Polytope
  
  Produces a d-dimensional Goldfarb cube if e<1/2 and g<=e/4. The Goldfarb cube is a combinatorial cube and yields a bad example for the Simplex Algorithm using the Shadow Vertex Pivoting Strategy. Here we use the description as a deformed product due to Amenta and Ziegler. For e<1/2 and g=0 we obtain the Klee-Minty cubes.
  Parameters
  Int d
  the dimension
  Scalar e
  Scalar g
  Returns
  Polytope
- goldfarb_sit (d, eps, delta) → Polytope
  
  Produces a d-dimensional variation of the Klee-Minty cube if eps<1/2 and delta<=1/2. This Klee-Minty cube is scaled in direction x_(d-i) by (eps*delta)^i. This cube is a combinatorial cube and yields a bad example for the Simplex Algorithm using the 'steepest edge' Pivoting Strategy. Here we use a scaled description of the construction of Goldfarb and Sit.
  Parameters
  Int d
  the dimension
  Scalar eps
  Scalar delta
  Returns
  Polytope
- hypersimplex (k, d) → Polytope
  
  Produce the hypersimplex Δ(k,d), that is the the convex hull of all 0/1-vector in R^d with exactly k 1s. Note that the output is never full-dimensional.
  Parameters
  Int k
  number of 1s
  Int d
  ambient dimension
  Options
  Bool group
  Bool no_vertices
  do not compute vertices
  Bool no_facets
  do not compute facets
  Bool no_vif
  do not compute vertices in facets
  Returns
  Polytope
  
  Example:
  This creates the hypersimplex in dimension 4 with vertices with exactly two 1-entries and computes its symmetry group:> $h = hypersimplex(2,4,group=>1);
- hypertruncated_cube <Scalar> (d, k, lambda) → Polytope<Scalar>
  
  Produce a d-dimensional hypertruncated cube. With symmetric linear objective function (0,1,1,...,1).
  Type Parameters
  Scalar
  Coordinate type of the resulting polytope. Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
  Parameters
  Int d
  the dimension
  Scalar k
  cutoff parameter
  Scalar lambda
  scaling of extra vertex
  Returns
  Polytope<Scalar>
- klee_minty_cube (d, e) → Polytope
  
  Produces a d-dimensional Klee-Minty-cube if e<1/2. Uses the goldfarb client with g=0.
  Parameters
  Int d
  the dimension
  Scalar e
  Returns
  Polytope
- k_cyclic (n, s) → Polytope
  
  Produce a (rounded) 2*k-dimensional k-cyclic polytope with n points, where k is the length of the input vector s. Special cases are the bicyclic (k=2) and tricyclic (k=3) polytopes. Only possible in even dimensions.
  The parameters s_i can be specified as integer, floating-point, or rational numbers. The coordinates of the i-th point are taken as follows:
  cos(s_1 * 2πi/n),
  sin(s_1 * 2πi/n),
  ...
  cos(s_k * 2πi/n),
  sin(s_k * 2πi/n)
  Warning: Some of the k-cyclic polytopes are not simplicial. Since the components are rounded, this function might output a polytope which is not a k-cyclic polytope!
  More information can be found in the following references:
  P. Schuchert: "Matroid-Polytope und Einbettungen kombinatorischer Mannigfaltigkeiten",
  PhD thesis, TU Darmstadt, 1995.
  Z. Smilansky: "Bi-cyclic 4-polytopes",
  Isr. J. Math. 70, 1990, 82-92
  Parameters
  Int n
  the number of points
  Vector s
  s=(s_1,...,s_k)
  Returns
  Polytope
  
  Example:
  To produce a (not exactly) regular pentagon, type this:> $p = k_cyclic(5,[1]);
- lecture_hall_simplex (d) → Polytope
  
  Produce a lecture hall d-simplex.
  Parameters
  Int d
  the dimension
  Options
  Bool group
  Returns
  Polytope
  
  Example:
  To create the 2-dimensional lecture hall simplex and compute its symmetry group, type this:> $p = lecture_hall_simplex(2,group=>1);> print $p->GROUP->GENERATORS; 1 0 2 2 0 1
- long_and_winding (r) → Polytope<PuiseuxFraction<Max, Rational, Rational> >
  
  Produce polytope in dimension 2r+2 with 3r+4 facets such that the total curvature of the central path is at least Omega(2^r). This establishes a counter-example to a continuous analog of the Hirsch conjecture by Deza, Terlaky and Zinchenko, Adv. Mech. Math. 17 (2009). The construction and its analysis can be found in Allamigeon, Benchimol, Gaubert and Joswig, arXiv: 1405.4161
  Parameters
  Int r
  defining parameter
  Options
  Rational eval_ratio
  parameter for evaluating the puiseux rational functions
  Int eval_exp
  to evaluate at eval_ratio^eval_exp, default: 1
  Float eval_float
  parameter for evaluating the puiseux rational functions
  Returns
  Polytope<PuiseuxFraction<Max, Rational, Rational> >
- max_GC_rank (d) → Polytope
  
  Produce a d-dimensional polytope of maximal Gomory-Chvatal rank Omega(d/log(d)), integrally infeasible. With symmetric linear objective function (0,1,1..,1). Construction due to Pokutta and Schulz.
  Parameters
  Int d
  the dimension
  Returns
  Polytope
- multiplex (d, n) → Polytope
  
  Produce a combinatorial description of a multiplex with parameters d and n. This yields a self-dual d-dimensional polytope with n+1 vertices.
  They are introduced by
  T. Bisztriczky,
  On a class of generalized simplices, Mathematika 43:27-285, 1996,
  see also
  M.M. Bayer, A.M. Bruening, and J.D. Stewart,
  A combinatorial study of multiplexes and ordinary polytopes,
  Discrete Comput. Geom. 27(1):49--63, 2002.
  Parameters
  Int d
  the dimension
  Int n
  Returns
  Polytope
- neighborly_cubical (d, n) → Polytope
  
  Produce the combinatorial description of a neighborly cubical polytope. The facets are labelled in oriented matroid notation as in the cubical Gale evenness criterion.
  See Joswig and Ziegler, Discr. Comput. Geom. 24:315-344 (2000).
  Parameters
  Int d
  dimension of the polytope
  Int n
  dimension of the equivalent cube
  Returns
  Polytope
- newton (p) → Polytope<Rational>
  
  Produce the Newton polytope of a polynomial p.
  Parameters
  Polynomial p
  Returns
  Polytope<Rational>
  
  Example:
  Create the newton polytope of 1+x^2+y like so:> $r=new Ring(qw(x y));> ($x,$y)=$r->variables;> $p=1+($x^2)+$y;> $n = newton($p);> print $n->VERTICES; 1 0 0 1 0 1 1 2 0
- n_gon (n, r) → Polytope
  
  Produce a regular n-gon. All vertices lie on a circle of radius r. The radius defaults to 1.
  Parameters
  Int n
  the number of vertices
  Rational r
  the radius
  Options
  Bool group
  Returns
  Polytope
  
  Example:
  To store the regular pentagon in the variable $p and calculate its symmetry group, do this:> $p = n_gon(5,group=>1);> print $p->GROUP->GENERATORS; 0 4 3 2 1 1 2 3 4 0
- perles_irrational_8_polytope () → Polytope
  
  Create an 8-dimensional polytope without rational realizations due to Perles
  Returns
  Polytope
- permutahedron (d) → Polytope
  
  Produce a d-dimensional permutahedron. The vertices correspond to the elements of the symmetric group of degree d+1.
  Parameters
  Int d
  the dimension
  Options
  Bool group
  Returns
  Polytope
  
  Example:
  To create the 3-permutahedron and also compute its symmetry group, do this:> $p = permutahedron(3,group=>1);> print $p->GROUP->GENERATORS; 1 0 2 3 3 0 1 2
- pile (sizes) → Polytope
  
  Produce a (d+1)-dimensional polytope from a pile of cubes. Start with a d-dimensional pile of cubes. Take a generic convex function to lift this polytopal complex to the boundary of a (d+1)-polytope.
  Parameters
  Vector<Int> sizes
  a vector (s₁,...,s_d, where s_i specifies the number of boxes in the i-th dimension.
  Returns
  Polytope
- pseudo_delpezzo (d, scale) → Polytope<Scalar>
  
  Produce a d-dimensional del-Pezzo polytope, which is the convex hull of the cross polytope together with the all-ones vector.
  All coordinates are +/- scale or 0.
  Parameters
  Int d
  the dimension
  Scalar scale
  the absolute value of each non-zero vertex coordinate. Needs to be positive. The default value is 1.
  Returns
  Polytope<Scalar>
- rand01 (d, n) → Polytope
  
  Produce a d-dimensional 0/1-polytope with n random vertices. Uniform distribution.
  Parameters
  Int d
  the dimension
  Int n
  the number of random vertices
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Polytope
- rand_box (d, n, b) → Polytope
  
  Computes the convex hull of n points sampled uniformly at random from the integer points in the cube [0,b]^d.
  Parameters
  Int d
  the dimension of the box
  Int n
  the number of random points
  Int b
  the size of the box
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Polytope
- rand_cyclic (d, n) → Polytope
  
  Computes a random instance of a cyclic polytope of dimension d on n vertices by randomly generating a Gale diagram whose cocircuits have alternating signs.
  Parameters
  Int d
  the dimension
  Int n
  the number of vertices
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Polytope
- rand_metric <Scalar> (n) → Matrix
  
  Produce an n-point metric with random distances. The values are uniformily distributed in [1,2].
  Type Parameters
  Scalar
  element type of the result matrix
  Parameters
  Int n
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Matrix
- rand_metric_int <Scalar> (n) → Matrix
  
  Produce an n-point metric with random distances. The values are uniformily distributed in [1,2].
  Type Parameters
  Scalar
  element type of the result matrix
  Parameters
  Int n
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Matrix
- rand_sphere (d, n) → Polytope
  
  Produce a d-dimensional polytope with n random vertices uniformly distributed on the unit sphere.
  Parameters
  Int d
  the dimension
  Int n
  the number of random vertices
  Options
  Int seed
  controls the outcome of the random number generator; fixing a seed number guarantees the same outcome.
  Returns
  Polytope
- rss_associahedron (l) → Polytope
  
  Produce a polytope of constrained expansions in dimension l according to
  Rote, Santos, and Streinu: Expansive motions and the polytope of pointed pseudo-triangulations.
  Discrete and computational geometry, 699--736, Algorithms Combin., 25, Springer, Berlin, 2003.
  Parameters
  Int l
  ambient dimension
  Returns
  Polytope
- signed_permutahedron (d) → Polytope
  
  Produce a d-dimensional signed permutahedron.
  Parameters
  Int d
  the dimension
  Returns
  Polytope
- simplex (d, scale) → Polytope
  
  Produce the standard d-simplex. Combinatorially equivalent to a regular polytope corresponding to the Coxeter group of type A_d-1. Optionally, the simplex can be scaled by the parameter scale.
  Parameters
  Int d
  the dimension
  Scalar scale
  default value: 1
  Options
  Bool group
  Returns
  Polytope
  
  Examples:
  To print the vertices (in homogeneous coordinates) of the standard 2-simplex, i.e. a right-angled isoceles triangle, type this:> print simplex(2)->VERTICES; (3) (0 1) 1 1 0 1 0 1 The first row vector is sparse and encodes the origin.
  To create a 3-simplex and also calculate its symmetry group, type this:> simplex(3,group=>1);
- stable_set (G) → Polytope
  
  Produces the stable set polytope from an undirected graph G=(V,E). The stable set Polytope has the following inequalities: x_i + x_j <= 1 forall {i,j} in E x_i >= 0 forall i in V x_i <= 1 forall i in V with deg(i)=0
  Parameters
  Graph G
  Returns
  Polytope
- transportation (r, c) → Polytope
  
  Produce the transportation polytope from two vectors r of length m and c of length n, i.e. all positive m×n Matrizes with row sums equal to r and column sums equal to c.
  Parameters
  Vector r
  Vector c
  Returns
  Polytope
- upper_bound_theorem (d, n) → Polytope
  
  Produce combinatorial data common to all simplicial d-polytopes with n vertices with the maximal number of facets as given by McMullen's Upper-Bound-Theorem. Essentially this lets you read off all possible entries of the H_VECTOR and the F_VECTOR.
  Parameters
  Int d
  the dimension
  Int n
  the number of points
  Returns
  Polytope
  
  Example:
  This produces the combinatorial data as mentioned above for 5 points in dimension 3 and prints the h-vector:> $p = upper_bound_theorem(3,5);> print $p->H_VECTOR; 1 2 2 1
- zonotope (M) → Polytope<Scalar>
  
  Create a zonotope from a matrix whose rows are input points or vectors.
  This method merely defines a Polytope object with the property ZONOTOPE_INPUT_POINTS.
  Parameters
  Matrix<Scalar> M
  input points or vectors
  Options
  Bool rows_are_points
  true if M are points instead of vectors; default true
  Bool centered
  true if output should be centered; default true
  Returns
  Polytope<Scalar>
  the zonotope generated by the input points or vectors
  
  Examples:
  The following produces a parallelogram with the origin as its vertex barycenter:> $M = new Matrix([[1,1,0],[1,1,1]]);> $p = zonotope($M);> print $p->VERTICES; 1 0 -1/2 1 0 1/2 1 -1 -1/2 1 1 1/2
  The following produces a parallelogram with the origin being a vertex (not centered case):> $M = new Matrix([[1,1,0],[1,1,1]]);> $p = zonotope($M,centered=>0);> print $p->VERTICES; 1 0 0 1 1 1 1 1 0 1 2 1
- zonotope_vertices_fukuda (M) → Matrix<E>
  
  Create the vertices of a zonotope from a matrix whose rows are input points or vectors.
  Parameters
  Matrix<Scalar> M
  Options
  Bool centered_zonotope
  default 1
  Returns
  Matrix<E>
  
  Example:
  The following stores the vertices of a parallelogram with the origin as its vertex barycenter and prints them:> $M = new Matrix([[1,1,0],[1,1,1]]);> print zonotope_vertices_fukuda($M); 1 0 -1/2 1 0 1/2 1 -1 -1/2 1 1 1/2
Producing a vector configuration
A way of constructing vector configurations is to modify an already existing vector configuration.
- projection (P, indices) → VectorConfiguration
  
  Orthogonally project a vector configuration to a coordinate subspace.
  The subspace the VectorConfiguration P is projected on is given by indices in the set indices. The option revert inverts the coordinate list.
  Parameters
  VectorConfiguration P
  Array<Int> indices
  Options
  Bool revert
  inverts the coordinate list
  Returns
  VectorConfiguration
- projection_full (P) → VectorConfiguration
  
  Orthogonally project a vector configuration to a coordinate subspace such that redundant columns are omitted, i.e., the projection becomes full-dimensional without changing the combinatorial type.
  Parameters
  VectorConfiguration P
  Options
  Bool relabel
  copy labels to projection
  Returns
  VectorConfiguration
Producing other objects
Functions producing big objects which are not contained in application polytope.
- coxeter_group (type) → group::GroupOfPolytope
  
  Produces the Coxeter group of type type. The Dynkin diagrams of the different types can be found in the description of the clients simple_roots_type_*.
  Parameters
  String type
  the type of the Coxeter group
  Returns
  group::GroupOfPolytope
  the Coxeter group of type type
- crosscut_complex (p) → topaz::SimplicialComplex
  
  Produce the crosscut complex of the boundary of a polytope.
  Parameters
  Polytope p
  Options
  Bool geometric_realization
  create a topaz::GeometricSimplicialComplex; default is true
  Returns
  topaz::SimplicialComplex

Producing regular polytopes and their generalizations

This includes the Platonic solids and their generalizations into two directions. In dimension 3 there are the Archimedean, Catalan and Johnson solids. In higher dimensions there are the simplices, the cubes, the cross polytopes and three other regular 4-polytopes.

archimedean_solid (s) → Polytope

Create Archimedean solid of the given name. Some polytopes are realized with floating point numbers and thus not exact; Vertex-facet-incidences are correct in all cases.

Parameters

the name of the desired Archimedean solid

Possible values:

'truncated_tetrahedron': Truncated tetrahedron. Regular polytope with four triangular and four hexagonal facets.
'cuboctahedron': Cuboctahedron. Regular polytope with eight triangular and six square facets.
'truncated_cube': Truncated cube. Regular polytope with eight triangular and six octagonal facets.
'truncated_octahedron': Truncated Octahedron. Regular polytope with six square and eight hexagonal facets.
'rhombicuboctahedron': Rhombicuboctahedron. Regular polytope with eight triangular and 18 square facets.
'truncated_cuboctahedron': Truncated Cuboctahedron. Regular polytope with 12 square, eight hexagonal and six octagonal facets.
'snub_cube': Snub Cube. Regular polytope with 32 triangular and six square facets. The vertices are realized as floating point numbers. This is a chiral polytope.
'icosidodecahedron': Icosidodecahedon. Regular polytope with 20 triangular and 12 pentagonal facets.
'truncated_dodecahedron': Truncated Dodecahedron. Regular polytope with 20 triangular and 12 decagonal facets.
'truncated_icosahedron': Truncated Icosahedron. Regular polytope with 12 pentagonal and 20 hexagonal facets.
'rhombicosidodecahedron': Rhombicosidodecahedron. Regular polytope with 20 triangular, 30 square and 12 pentagonal facets.
'truncated_icosidodecahedron': Truncated Icosidodecahedron. Regular polytope with 30 square, 20 hexagonal and 12 decagonal facets.
'snub_dodecahedron': Snub Dodecahedron. Regular polytope with 80 triangular and 12 pentagonal facets. The vertices are realized as floating point numbers. This is a chiral polytope.

Returns

Example:

To show the mirror image of the snub cube use:> scale(archimedean_solid('snub_cube'),-1)->VISUAL;

catalan_solid (s) → Polytope

Create Catalan solid of the given name. Some polytopes are realized with floating point numbers and thus not exact; Vertex-facet-incidences are correct in all cases.

Parameters

the name of the desired Catalan solid

Possible values:

'triakis_tetrahedron': Triakis Tetrahedron. Dual polytope to the Truncated Tetrahedron, made of 12 isosceles triangular facets.
'triakis_octahedron': Triakis Octahedron. Dual polytope to the Truncated Cube, made of 24 isosceles triangular facets.
'rhombic_dodecahedron': Rhombic dodecahedron. Dual polytope to the cuboctahedron, made of 12 rhombic facets.
'tetrakis_hexahedron': Tetrakis hexahedron. Dual polytope to the truncated octahedron, made of 24 isosceles triangluar facets.
'disdyakis_dodecahedron': Disdyakis dodecahedron. Dual polytope to the truncated cuboctahedron, made of 48 scalene triangular facets.
'pentagonal_icositetrahedron': Pentagonal Icositetrahedron. Dual polytope to the snub cube, made of 24 irregular pentagonal facets. The vertices are realized as floating point numbers.
'pentagonal_hexecontahedron': Pentagonal Hexecontahedron. Dual polytope to the snub dodecahedron, made of 60 irregular pentagonal facets. The vertices are realized as floating point numbers.
'rhombic_triacontahedron': Rhombic triacontahedron. Dual polytope to the icosidodecahedron, made of 30 rhombic facets.
'triakis_icosahedron': Triakis icosahedron. Dual polytope to the icosidodecahedron, made of 30 rhombic facets.
'deltoidal_icositetrahedron': Deltoidal Icositetrahedron. Dual polytope to the rhombicubaoctahedron, made of 24 kite facets.
'pentakis_dodecahedron': Pentakis dodecahedron. Dual polytope to the truncated icosahedron, made of 60 isosceles triangular facets.
'deltoidal_hexecontahedron': Deltoidal hexecontahedron. Dual polytope to the rhombicosidodecahedron, made of 60 kite facets.
'disdyakis_triacontahedron': Disdyakis triacontahedron. Dual polytope to the truncated icosidodecahedron, made of 120 scalene triangular facets.

Returns

cross <Scalar> (d, scale) → Polytope<Scalar>
Produce a d-dimensional cross polytope. Regular polytope corresponding to the Coxeter group of type B_d-1 = C_d-1.
All coordinates are +/- scale or 0.
Type Parameters
Scalar
Coordinate type of the resulting polytope. Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
Parameters
Int d
the dimension
Scalar scale
the absolute value of each non-zero vertex coordinate. Needs to be positive. The default value is 1.
Options
Bool group
add a symmetry group description to the resulting polytope
Returns
Polytope<Scalar>
Example:
To create the 3-dimensional cross polytope, type> $p = cross(3); Check out it's vertices and volume:> print $p->VERTICES; 1 1 0 0 1 -1 0 0 1 0 1 0 1 0 -1 0 1 0 0 1 1 0 0 -1> print cross(3)->VOLUME; 4/3 If you rather had a bigger one, type> $p_scaled = cross(3,2);> print $p_scaled->VOLUME; 32/3 To also calculate the symmetry group, do this:> $p = cross(3,group=>1); You can then print the generators of this group like this:> print $p->GROUP->GENERATORS; 1 0 2 3 4 5 2 3 0 1 4 5 0 1 4 5 2 3
cube <Scalar> (d, x_up, x_low) → Polytope<Scalar>
Produce a d-dimensional cube. Regular polytope corresponding to the Coxeter group of type B_d-1 = C_d-1.
The bounding hyperplanes are x_i <= x_up and x_i >= x_low.
Type Parameters
Scalar
Coordinate type of the resulting polytope. Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
Parameters
Int d
the dimension
Scalar x_up
upper bound in each dimension
Scalar x_low
lower bound in each dimension
Options
Bool group
add a symmetry group description to the resulting polytope
Returns
Polytope<Scalar>
Examples:
This yields a +/-1 cube of dimension 3 and stores it in the variable $c.> $c = cube(3);
This stores a standard unit cube of dimension 3 in the variable $c.> $c = cube(3,0);
This prints the area of a square with side length 4 translated to have its vertex barycenter at [5,5]:> print cube(2,7,3)->VOLUME; 16
cuboctahedron () → Polytope

Create cuboctahedron. An Archimedean solid.
Returns
Polytope
dodecahedron () → Polytope

Create exact regular dodecahedron in Q(sqrt{5}). A Platonic solid.
Returns
Polytope
icosahedron () → Polytope

Create exact regular icosahedron in Q(sqrt{5}). A Platonic solid.
Returns
Polytope
icosidodecahedron () → Polytope

Create exact icosidodecahedron in Q(sqrt{5}). An Archimedean solid.
Returns
Polytope
johnson_solid (n) → Polytope

Create Johnson solid number n.
Parameters
Int n
the index of the desired Johnson polytope
Returns
Polytope

johnson_solid (s) → Polytope

Create Johnson solid with the given name. Some polytopes are realized with floating point numbers and thus not exact; Vertex-facet-incidences are correct in all cases.

Parameters

the name of the desired Johnson polytope

Possible values:

'square_pyramid': Square pyramid with regular facets. Johnson solid J1.
'pentagonal_pyramid': Pentagonal pyramid with regular facets. Johnson solid J2.
'triangular_cupola': Triangular cupola with regular facets. Johnson solid J3.
'square_cupola': Square cupola with regular facets. Johnson solid J4.
'pentagonal_cupola': Pentagonal cupola with regular facets. Johnson solid J5.
'pentagonal_rotunda': Pentagonal rotunda with regular facets. Johnson solid J6.
'elongated_triangular_pyramid': Elongated triangular pyramid with regular facets. Johnson solid J7.
'elongated_square_pyramid': Elongated square pyramid with regular facets. Johnson solid J8.
'elongated_pentagonal_pyramid': Elongated pentagonal pyramid with regular facets. Johnson solid J9. The vertices are realized as floating point numbers.
'gyroelongated_square_pyramid': Gyroelongated square pyramid with regular facets. Johnson solid J10. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_pyramid': Gyroelongated pentagonal pyramid with regular facets. Johnson solid J11.
'triangular_bipyramid': Triangular bipyramid with regular facets. Johnson solid J12.
'pentagonal_bipyramid': Pentagonal bipyramid with regular facets. Johnson solid J13. The vertices are realized as floating point numbers.
'elongated_triangular_bipyramid': Elongated triangular bipyramid with regular facets. Johnson solid J14.
'elongated_square_bipyramid': Elongated square bipyramid with regular facets. Johnson solid J15.
'elongated_pentagonal_bipyramid': Elongated pentagonal bipyramid with regular facets. Johnson solid J16. The vertices are realized as floating point numbers.
'gyroelongated_square_bipyramid': Gyroelongted square bipyramid with regular facets. Johnson solid J17. The vertices are realized as floating point numbers.
'elongated_triangular_cupola': Elongted triangular cupola with regular facets. Johnson solid J18. The vertices are realized as floating point numbers.
'elongated_square_cupola': Elongted square cupola with regular facets. Johnson solid J19.
'elongated_pentagonal_cupola': Elongted pentagonal cupola with regular facets. Johnson solid J20 The vertices are realized as floating point numbers.
'elongated_pentagonal_rotunda': Elongated pentagonal rotunda with regular facets. Johnson solid J21. The vertices are realized as floating point numbers.
'gyroelongated_triangular_cupola': Gyroelongted triangular cupola with regular facets. Johnson solid J22. The vertices are realized as floating point numbers.
'gyroelongated_square_cupola': Gyroelongted square cupola with regular facets. Johnson solid J23. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_cupola': Gyroelongted pentagonal cupola with regular facets. Johnson solid J24. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_rotunda': Gyroelongted pentagonal rotunda with regular facets. Johnson solid J25. The vertices are realized as floating point numbers.
'gyrobifastigium': Gyrobifastigium with regular facets. Johnson solid J26.
'triangular_orthobicupola': Triangular orthobicupola with regular facets. Johnson solid J27.
'square_orthobicupola': Square orthobicupola with regular facets. Johnson solid J28.
'square_gyrobicupola': Square gyrobicupola with regular facets. Johnson solid J29.
'pentagonal_orthobicupola': Pentagonal orthobicupola with regular facets. Johnson solid J30. The vertices are realized as floating point numbers.
'pentagonal_gyrobicupola': Pentagonal gyrobicupola with regular facets. Johnson solid J31. The vertices are realized as floating point numbers.
'pentagonal_orthocupolarotunda': Pentagonal orthocupolarotunda with regular facets. Johnson solid J32. The vertices are realized as floating point numbers.
'pentagonal_gyrocupolarotunda': Pentagonal gyrocupolarotunda with regular facets. Johnson solid J33. The vertices are realized as floating point numbers.
'pentagonal_orthobirotunda': Pentagonal orthobirotunda with regular facets. Johnson solid J32. The vertices are realized as floating point numbers.
'elongated_triangular_orthbicupola': Elongated triangular orthobicupola with regular facets. Johnson solid J35. The vertices are realized as floating point numbers.
'elongated_triangular_gyrobicupola': Elongated triangular gyrobicupola with regular facets. Johnson solid J36. The vertices are realized as floating point numbers.
'elongated_square_gyrobicupola': Elongated square gyrobicupola with regular facets. Johnson solid J37.
'elongated_pentagonal_orthobicupola': Elongated pentagonal orthobicupola with regular facets. Johnson solid J38. The vertices are realized as floating point numbers.
'elongated_pentagonal_gyrobicupola': Elongated pentagonal gyrobicupola with regular facets. Johnson solid J39. The vertices are realized as floating point numbers.
'elongated_pentagonal_orthocupolarotunda': Elongated pentagonal orthocupolarotunda with regular facets. Johnson solid J40. The vertices are realized as floating point numbers.
'elongated_pentagonal_gyrocupolarotunda': Elongated pentagonal gyrocupolarotunda with regular facets. Johnson solid J41. The vertices are realized as floating point numbers.
'elongated_pentagonal_orthobirotunda': Elongated pentagonal orthobirotunda with regular facets. Johnson solid J42. The vertices are realized as floating point numbers.
'elongated_pentagonal_gyrobirotunda': Elongated pentagonal gyrobirotunda with regular facets. Johnson solid J43. The vertices are realized as floating point numbers.
'gyroelongated_triangular_bicupola': Gyroelongated triangular bicupola with regular facets. Johnson solid J44. The vertices are realized as floating point numbers.
'elongated_square_bicupola': Elongated square bicupola with regular facets. Johnson solid J45. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_bicupola': Gyroelongated pentagonal bicupola with regular facets. Johnson solid J46. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_cupolarotunda': Gyroelongated pentagonal cupolarotunda with regular facets. Johnson solid J47. The vertices are realized as floating point numbers.
'gyroelongated_pentagonal_birotunda': Gyroelongated pentagonal birotunda with regular facets. Johnson solid J48. The vertices are realized as floating point numbers.
'augmented_triangular_prism': Augmented triangular prism with regular facets. Johnson solid J49. The vertices are realized as floating point numbers.
'biaugmented_triangular_prism': Biaugmented triangular prism with regular facets. Johnson solid J50. The vertices are realized as floating point numbers.
'triaugmented_triangular_prism': Triaugmented triangular prism with regular facets. Johnson solid J51. The vertices are realized as floating point numbers.
'augmented_pentagonal_prism': Augmented prantagonal prism with regular facets. Johnson solid J52. The vertices are realized as floating point numbers.
'biaugmented_pentagonal_prism': Augmented pentagonal prism with regular facets. Johnson solid J53. The vertices are realized as floating point numbers.
'augmented_hexagonal_prism': Augmented hexagonal prism with regular facets. Johnson solid J54. The vertices are realized as floating point numbers.
'parabiaugmented_hexagonal_prism': Parabiaugmented hexagonal prism with regular facets. Johnson solid J55. The vertices are realized as floating point numbers.
'metabiaugmented_hexagonal_prism': Metabiaugmented hexagonal prism with regular facets. Johnson solid J56. The vertices are realized as floating point numbers.
'triaugmented_hexagonal_prism': triaugmented hexagonal prism with regular facets. Johnson solid J57. The vertices are realized as floating point numbers.
'augmented_dodecahedron': Augmented dodecahedron with regular facets. Johnson solid J58. The vertices are realized as floating point numbers.
'parabiaugmented_dodecahedron': Parabiaugmented dodecahedron with regular facets. Johnson solid J59. The vertices are realized as floating point numbers.
'metabiaugmented_dodecahedron': Metabiaugmented dodecahedron with regular facets. Johnson solid J60. The vertices are realized as floating point numbers.
'triaugmented_dodecahedron': Triaugmented dodecahedron with regular facets. Johnson solid J61. The vertices are realized as floating point numbers.
'metabidiminished_icosahedron': Metabidiminished icosahedron with regular facets. Johnson solid J62.
'tridiminished_icosahedron': Tridiminished icosahedron with regular facets. Johnson solid J63.
'augmented_tridiminished_icosahedron': Augmented tridiminished icosahedron with regular facets. Johnson solid J64. The vertices are realized as floating point numbers.
'augmented_truncated_tetrahedron': Augmented truncated tetrahedron with regular facets. Johnson solid J65.
'augmented_truncated_cube': Augmented truncated cube with regular facets. Johnson solid J66.
'biaugmented_truncated_cube': Biaugmented truncated cube with regular facets. Johnson solid J67.
'augmented_truncated_dodecahedron': Augmented truncated dodecahedron with regular facets. Johnson solid J68. The vertices are realized as floating point numbers.
'parabiaugmented_truncated_dodecahedron': Parabiaugmented truncated dodecahedron with regular facets. Johnson solid J69. The vertices are realized as floating point numbers.
'metabiaugmented_truncated_dodecahedron': Metabiaugmented truncated dodecahedron with regular facets. Johnson solid J70. The vertices are realized as floating point numbers.
'triaugmented_truncated_dodecahedron': Triaugmented truncated dodecahedron with regular facets. Johnson solid J71. The vertices are realized as floating point numbers.
'gyrate_rhombicosidodecahedron': Gyrate rhombicosidodecahedron with regular facets. Johnson solid J72. The vertices are realized as floating point numbers.
'parabigyrate_rhombicosidodecahedron': Parabigyrate rhombicosidodecahedron with regular facets. Johnson solid J73. The vertices are realized as floating point numbers.
'metabigyrate_rhombicosidodecahedron': Metabigyrate rhombicosidodecahedron with regular facets. Johnson solid J74. The vertices are realized as floating point numbers.
'trigyrate_rhombicosidodecahedron': Trigyrate rhombicosidodecahedron with regular facets. Johnson solid J75. The vertices are realized as floating point numbers.
'diminished_rhombicosidodecahedron': Diminished rhombicosidodecahedron with regular facets. Johnson solid J76.
'paragyrate_diminished_rhombicosidodecahedron': Paragyrate diminished rhombicosidodecahedron with regular facets. Johnson solid J77. The vertices are realized as floating point numbers.
'metagyrate_diminished_rhombicosidodecahedron': Metagyrate diminished rhombicosidodecahedron with regular facets. Johnson solid J78. The vertices are realized as floating point numbers.
'bigyrate_diminished_rhombicosidodecahedron': Bigyrate diminished rhombicosidodecahedron with regular facets. Johnson solid J79. The vertices are realized as floating point numbers.
'parabidiminished_rhombicosidodecahedron': Parabidiminished rhombicosidodecahedron with regular facets. Johnson solid J80.
'metabidiminished_rhombicosidodecahedron': Metabidiminished rhombicosidodecahedron with regular facets. Johnson solid J81.
'gyrate_bidiminished_rhombicosidodecahedron': Gyrate bidiminished rhombicosidodecahedron with regular facets. Johnson solid J82. The vertices are realized as floating point numbers.
'triminished_rhombicosidodecahedron': Tridiminished rhombicosidodecahedron with regular facets. Johnson solid J83.
'snub_disphenoid': Snub disphenoid with regular facets. Johnson solid J84. The vertices are realized as floating point numbers.
'snub_square_antisprim': Snub square antiprism with regular facets. Johnson solid J85. The vertices are realized as floating point numbers.
'sphenocorona': Sphenocorona with regular facets. Johnson solid J86. The vertices are realized as floating point numbers.
'augmented_sphenocorona': Augmented sphenocorona with regular facets. Johnson solid J87. The vertices are realized as floating point numbers.
'sphenomegacorona': Sphenomegacorona with regular facets. Johnson solid J88. The vertices are realized as floating point numbers.
'hebesphenomegacorona': Hebesphenomegacorona with regular facets. Johnson solid J89. The vertices are realized as floating point numbers.
'disphenocingulum': Disphenocingulum with regular facets. Johnson solid J90. The vertices are realized as floating point numbers.
'bilunabirotunda': Bilunabirotunda with regular facets. Johnson solid J91.
'triangular_hebesphenorotunda': Triangular hebesphenorotunda with regular facets. Johnson solid J92.

Returns

platonic_solid (s) → Polytope

Create Platonic solid of the given name.

Parameters

the name of the desired Platonic solid

Possible values:

'tetrahedron': Tetrahedron. Regular polytope with four triangular facets.
'cube': Cube. Regular polytope with six square facets.
'octahedron': Octahedron. Regular polytope with eight triangular facets.
'dodecahedron': Dodecahedron. Regular polytope with 12 pentagonal facets.
'icosahedron': Icosahedron. Regular polytope with 20 triangular facets.

Returns

regular_120_cell () → Polytope

Create exact regular 120-cell in Q(sqrt{5}).
Returns
Polytope
regular_24_cell () → Polytope

Create regular 24-cell.
Returns
Polytope
regular_600_cell () → Polytope

Create exact regular 600-cell in Q(sqrt{5}).
Returns
Polytope
regular_simplex (d) → Polytope
Produce a regular d-simplex embedded in R^d with edge length sqrt(2).
Parameters
Int d
the dimension
Options
Bool group
Returns
Polytope
Examples:
To print the vertices (in homogeneous coordinates) of the regular 2-simplex, i.e. an equilateral triangle, type this:> print regular_simplex(2)->VERTICES; 1 1 0 1 0 1 1 1/2-1/2r3 1/2-1/2r3 The polytopes cordinate type is QuadraticExtension<Rational>, thus numbers that can be represented as a + b*sqrt(c) with Rational numbers a, b and c. The last row vectors entrys thus represent the number 1/2*(1-sqrt(3)).
To store a regular 3-simplex in the variable $s and also calculate its symmetry group, type this:> $s = regular_simplex(3,group=>1); You can then print the groups generators like so:> print $s->GROUP->GENERATORS; 1 0 2 2 0 1
rhombicosidodecahedron () → Polytope

Create exact rhombicosidodecahedron in Q(sqrt{5}). An Archimedean solid.
Returns
Polytope
rhombicuboctahedron () → Polytope

Create rhombicuboctahedron. An Archimedean solid.
Returns
Polytope
simple_roots_type_A (index) → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type A Indices are taken w.r.t. the Dynkin diagram 0 ---- 1 ---- ... ---- n-1 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length sqrt{2}.
Parameters
Int index
of the arrangement (3, 4, etc)
Returns
SparseMatrix
simple_roots_type_B (index) → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type B Indices are taken w.r.t. the Dynkin diagram 0 ---- 1 ---- ... ---- n-2 --(4)--> n-1 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length sqrt{2}.
Parameters
Int index
of the arrangement (3, 4, etc)
Returns
SparseMatrix
simple_roots_type_C (index) → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type C Indices are taken w.r.t. the Dynkin diagram 0 ---- 1 ---- ... ---- n-2 <--(4)-- n-1 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length sqrt{2}.
Parameters
Int index
of the arrangement (3, 4, etc)
Returns
SparseMatrix
simple_roots_type_D (index) → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type D Indices are taken w.r.t. the Dynkin diagram n-2 / 0 - 1 - ... - n-3
n-1 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length sqrt{2}.
Parameters
Int index
of the arrangement (3, 4, etc)
Returns
SparseMatrix
simple_roots_type_E6 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type E6 Indices are taken w.r.t. the Dynkin diagram 3 | | 0 ---- 1 ---- 2 ---- 4 ---- 5 Note that the roots lie at infinity to facilitate reflecting in them.
Returns
SparseMatrix
simple_roots_type_E7 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type E7 Indices are taken w.r.t. the Dynkin diagram 4 | | 0 ---- 1 ---- 2 ---- 3 ---- 5 ---- 6 Note that the roots lie at infinity to facilitate reflecting in them.
Returns
SparseMatrix
simple_roots_type_E8 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type E8 Indices are taken w.r.t. the Dynkin diagram 5 | | 0 ---- 1 ---- 2 ---- 3 ---- 4 ---- 6 ---- 7 Note that the roots lie at infinity to facilitate reflecting in them.
Returns
SparseMatrix
simple_roots_type_F4 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type F4 Indices are taken w.r.t. the Dynkin diagram 0 ---- 1 --(4)--> 2 ---- 3
Returns
SparseMatrix
simple_roots_type_G2 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type G2 Indices are taken w.r.t. the Dynkin diagram 0 <--(6)-- 1
Returns
SparseMatrix
simple_roots_type_H3 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type H3 Indices are taken w.r.t. the Dynkin diagram 0 --(5)-- 1 ---- 2 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length 2
Returns
SparseMatrix
simple_roots_type_H4 () → SparseMatrix

Produce the simple roots of the Coxeter arrangement of type H4 Indices are taken w.r.t. the Dynkin diagram 0 --(5)-- 1 ---- 2 ---- 3 Note that the roots lie at infinity to facilitate reflecting in them, and are normalized to length sqrt{2}
Returns
SparseMatrix
tetrahedron () → Polytope

Create regular tetrahedron. A Platonic solid.
Returns
Polytope
truncated_cube () → Polytope

Create truncated cube. An Archimedean solid.
Returns
Polytope
truncated_cuboctahedron () → Polytope

Create truncated cuboctahedron. An Archimedean solid. This is actually a misnomer. The actual truncation of a cuboctahedron is normally equivalent to this construction, but has two different edge lengths. This construction has regular 2-faces.
Returns
Polytope
truncated_dodecahedron () → Polytope

Create exact truncated dodecahedron in Q(sqrt{5}). An Archimedean solid.
Returns
Polytope
truncated_icosahedron () → Polytope

Create exact truncated icosahedron in Q(sqrt{5}). An Archimedean solid. Also known as the soccer ball.
Returns
Polytope
truncated_icosidodecahedron () → Polytope

Create exact truncated icosidodecahedron in Q(sqrt{5}). An Archimedean solid.
Returns
Polytope
truncated_octahedron () → Polytope

Create truncated octahedron. An Archimedean solid. Also known as the 3-permutahedron.
Returns
Polytope

wythoff (type, rings) → Polytope

Produce the orbit polytope of a point under a Coxeter arrangement with exact coordinates, possibly in a qudratic extension field of the rationals

Parameters

String	type	single letter followed by rank representing the type of the arrangement
Set<Int>	rings	indices of the hyperplanes corresponding to simple roots of the arrangement that the initial point should NOT lie on

Returns

Quotient spaces
Topologic cell complexes defined as quotients over polytopes modulo a discrete group.
- cs_quotient (P)
  
  For a centrally symmetric polytope, divide out the central symmetry, i.e, identify diametrically opposite faces.
  Contained in extension bundled:group.
  Parameters
  Polytope P
  , centrally symmetric
- cylinder_2 () → Polytope
  
  Return a 2-dimensional cylinder obtained by identifying two opposite sides of a square.
  Contained in extension bundled:group.
  Returns
  Polytope
- quarter_turn_manifold () → Polytope
  
  Return the 3-dimensional Euclidean manifold obtained by identifying opposite faces of a 3-dimensional cube by a quarter turn. After identification, two classes of vertices remain.
  Contained in extension bundled:group.
  Returns
  Polytope
- write_quotient_space_simplexity_ilp ()
  
  outputs a linear program whose optimal value is a lower bound for the number of simplices necessary to triangulate the polytope in such a way that its symmetries respect the triangulation of the boundary.
  Contained in extension bundled:group.

Symmetry

These functions capture information of the object that is concerned with the action of permutation groups.

alternating_group (degree, domain) → group::GroupOfPolytope

Constructs an alternating group of given degree. (See also group::alternating_group.)
Contained in extension bundled:group.
Parameters
Int degree
Int domain
of the polytope's symmetry group
Returns
group::GroupOfPolytope

combinatorial_symmetries (poly, on_vertices) → group::GroupOfPolytope

Compute the combinatorial symmetries (i.e., automorphisms of the face lattice) of a given polytope poly. If on_vertices is set to 1, the function returns a GroupOfPolytope which acts on the vertices. If on_vertices is set to any other number, the function returns a GroupOfPolytope which acts on the facets of the polytope. If on_vertices is unspecified, both groups are returned.

Parameters

Polytope	poly
Int	on_vertices	specifies whether the returned group should act on vertices (1) or on facets (2)

Returns

group::GroupOfPolytope

the combinatorial symmetry group acting on the vertices or the facets or (group::GroupOfPolytope, group::GroupOfPolytope) = (group on vertices, group on facets) if on_vertices is undefined

Example:

To get the vertex and facet symmetry groups of the square and print their generators, type the following:> ($gv,$gf) = combinatorial_symmetries(cube(2));> print $gv->GENERATORS; 2 3 0 1 1 0 2 3> print $gf->GENERATORS; 0 2 1 3 1 0 3 2

convert_coord_action (group, mat, dom_out) → group::Group

Converts the generators of a group acting on coordinates to generators of the corresponding group which acts on the rows of the given matrix mat. The parameter dom_out specifies whether mat describes vertices or facets.
Contained in extension bundled:group.
Parameters
group::Group group
input group acting on coordinates
Matrix mat
vertices or facets of a polytope
Int dom_out
OnRays(1) or OnFacets(2)
Options
String name
an optional name for the output group
Returns
group::Group
a new group object with the generators induced on the new domain
convert_group_domain (group, VIF) → group::Group

Converts the generators of the input group from the domain onRays to generators on the domain onFacets, and vice versa.
Contained in extension bundled:group.
Parameters
group::Group group
IncidenceMatrix VIF
the vertex-facet incidence matrix of the cone or polytope
Options
String name
an optional name for the output group
Returns
group::Group
a new group object with the generators induced on the new domain
cyclic_group (degree, domain) → group::GroupOfPolytope

Constructs a cyclic group of given degree. (See also group::cyclic_group.)
Contained in extension bundled:group.
Parameters
Int degree
Int domain
of the polytope's symmetry group
Returns
group::GroupOfPolytope
group_from_cyclic_notation0 (group, domain) → group::GroupOfPolytope
Constructs a group from a string with generators in cyclic notation. All numbers in the string are 0-based, meaning that 0 is the smallest number allowed.
Contained in extension bundled:group.
Parameters
String group
generators in cyclic notation
Int domain
of the polytope symmetry group. 1 for action on vertex indices, 2 for action" on facet indices, 3 for action on coordinates
Returns
group::GroupOfPolytope
Example:
> $g = group_from_cyclic_notation0("(0,2)(1,3)",0);> print $g->GENERATORS; 2 3 0 1
group_from_cyclic_notation1 (group, domain) → group::GroupOfPolytope

Constructs a group from a string with generators in cyclic notation. All numbers in the string are 1-based, meaning that 1 is the smallest number allowed. Example: "(1,3)(2,4)"
Contained in extension bundled:group.
Parameters
String group
generators in cyclic notation
Int domain
of the polytope symmetry group. 1 for action on vertex indices, 2 for action" on facet indices, 3 for action on coordinates
Returns
group::GroupOfPolytope
# @example > $g = group_from_cyclic_notation1("(1,3)(2,4)",0); > print $g->GENERATORS; | 2 3 0 1
lattice_automorphisms_smooth_polytope (P) → Array<Array<Int>>
Returns a generating set for the lattice automorphism group of a smooth polytope P by comparing lattice distances between vertices and facets.
Parameters
Polytope P
the given polytope
Returns
Array<Array<Int>>
the generating set for the lattice automorphism group
Example:
> print lattice_automorphisms_smooth_polytope(cube(2)); 2 3 0 1 1 0 3 2 0 2 1 3
linear_symmetries (m) → group::Group
Computes the linear symmetries of a matrix m whose rows describe a point configuration via 'sympol'.
Contained in extension bundled:group.
Parameters
Matrix m
holds the points as rows whose linear symmetry group is to be computed
Returns
group::Group
the linear symmetry group of m
Example:
> $ls = linear_symmetries(cube(2)->VERTICES);> print $ls->GENERATORS; 0 2 1 3 3 1 2 0 2 3 0 1
linear_symmetries (c, dual) → group::GroupOfCone

Computes the linear symmetries of a given polytope p via 'sympol'. If the input is a cone, it may compute only a subgroup of the linear symmetry group.
Contained in extension bundled:group.
Parameters
Cone c
the cone (or polytope) whose linear symmetry group is to be computed
Bool dual
true if group action on vertices, false if action on facets
Returns
group::GroupOfCone
the linear symmetry group of p (or a subgroup if p is a cone)

nestedOPGraph (gen_point, points, lattice_points, group, verbose) → ARRAY

Constructs the NOP-graph of an orbit polytope. It is used by the rule for the NOP_GRAPH.

Parameters

Vector	gen_point	the generating point
Matrix	points	the vertices of the orbit polytope
Matrix	lattice_points	the lattice points of the orbit polytope
group::GroupOfPolytope	group	the generating group
Bool	verbose	print out additional information

Returns

ARRAY

($Graph, $lp_reps, $minInStartOrbit, \@core_point_reps, $CPindices)

orbit_polytope (gen_point, group) → OrbitPolytope

Constructs the orbit polytope of a given point gen_point with respect to a given permutation group group.
Parameters
Vector<Rational> gen_point
the basis point of the orbit polytope
group::GroupOfPolytope group
a group acting on coordinates
Returns
OrbitPolytope
the orbit polytope of gen_point w.r.t. group
ortho_project (p) → Polytope

Projects a symmetric polytope in R⁴ cap H_1,k to R³. (See also the polymake extension 'tropmat' by S. Horn.)
Parameters
Polytope p
the symmetric polytope to be projected
Returns
Polytope
the image of p in R³

representation_conversion_up_to_symmetry (c, a, dual, rayCompMethod) → List

Computes the dual description of a polytope up to its linear symmetry group.

Contained in extension bundled:group.

Parameters

Cone	c	the cone (or polytope) whose dual description is to be computed
group::Group	a	symmetry group of the cone c (group::GroupOfCone or group::GroupOfPolytope)
Bool	dual	true if V to H, false if H to V
Int	rayCompMethod	specifies sympol's method of ray computation via lrs(0), cdd(1), beneath_and_beyond(2), ppl(3)

Returns

List	(Bool success indicator, Matrix<Rational> vertices/inequalities, Matrix<Rational> lineality/equations)

symmetric_group (degree, domain) → group::GroupOfPolytope
Constructs a symmetric group of given degree. (See also group::symmetric_group.)
Contained in extension bundled:group.
Parameters
Int degree
Int domain
of the polytope's symmetry group. 1 for action on vertex indices, 2 for action" on facet indices, 3 for action on coordinates
Returns
group::GroupOfPolytope
Example:
> $g = symmetric_group(5,0);> print $g->GENERATORS; 1 0 2 3 4 0 2 1 3 4 0 1 3 2 4 0 1 2 4 3

truncated_orbit_polytope (v, group, eps) → SymmetricPolytope

Constructs an orbit polytope of a given point v with respect to a given group group, in which all vertices are cut off by hyperplanes in distance eps

Contained in extension bundled:group.

Parameters

Vector	v	point of which orbit polytope is to be constructed
group::GroupOfPolytope	group	group for which orbit polytope is to be constructed
Rational	eps	scaled distance by which the vertices of the orbit polytope are to be cut off

Returns

SymmetricPolytope

the truncated orbit polytope

visualizeNOP (orb, colors_ref, trans_ref)

Visualizes all (nested) orbit polytopes contained in orb in one picture.
Parameters
OrbitPolytope orb
the orbit polytope
ARRAY colors_ref
the reference to an array of colors
ARRAY trans_ref
the reference to an array of transparency values
visualizeNOPGraph (orb, filename)

Visualizes the NOP-graph of an orbit polytope. Requires 'graphviz' and a Postscript viewer. Produces a file which is to be processed with the program 'dot' from the graphviz package. If 'dot' is installed, the NOP-graph is visualized by the Postscript viewer.
Parameters
OrbitPolytope orb
the orbit polytope
String filename
the filename for the 'dot' file

Transformations
These functions take a realized polytope and produce a new one by applying a suitable affine or projective transformation in order to obtain some special coordinate description but preserve the combinatorial type.
For example, before you can polarize an arbitrary polyhedron, it must be transformed to a combinatorially equivalent bounded polytope with the origin as a relatively interior point. It is achieved with the sequence orthantify - bound - center - polarize.
- ambient_lattice_normalization (p) → Polytope
  
  Transform to a full-dimensional polytope while preserving the ambient lattice Z^n
  Parameters
  Polytope p
  the input polytope,
  Options
  Bool store_transform
  store the reverse transformation as an attachement
  Returns
  Polytope
  - the transformed polytope defined by its vertices. Facets are only written if available in p.
  
  Examples:
  Consider a line segment embedded in 2-space containing three lattice points:> $p = new Polytope(VERTICES=>[[1,0,0],[1,2,2]]);> print ambient_lattice_normalization($p)->VERTICES; 1 0 1 2 The ambient lattice of the projection equals the intersection of the affine hull of $p with Z^2.
  Another line segment containing only two lattice points:> $p = new Polytope(VERTICES=>[[1,0,0],[1,1,2]]);> $P = ambient_lattice_normalization($p,store_transform=>1);> print $P->VERTICES; 1 0 1 1 To get the transformation, do the following:> print $M = $P->get_attachment(REVERSE_LATTICE_PROJECTION); 1 0 0 0 1 2> print $P->VERTICES * $M; 1 0 0 1 1 2
- bound (P) → Polytope
  
  Make a positive polyhedron bounded. Apply a projective linear transformation to a polyhedron mapping the far hyperplane to the hyperplane spanned by the unit vectors. The origin (1,0,...,0) is fixed.
  The input polyhedron should be POSITIVE; i.e. no negative coordinates.
  Parameters
  Polytope P
  a positive polyhedron
  Returns
  Polytope
  
  Example:
  Observe the transformation of a simple unbounded 2-polyhedron:> $P = new Polytope(VERTICES=>[[1,0,0],[0,1,1],[0,0,1]]);> print bound($P)->VERTICES; 1 0 0 1 1/2 1/2 1 0 1 As you can see, the far points are mapped to the hyperplane spanned by (1,1,0) and (1,0,1).
- center (P) → Polytope
  
  Make a polyhedron centered. Apply a linear transformation to a polyhedron P such that a relatively interior point (preferably the vertex barycenter) is moved to the origin (1,0,...,0).
  Parameters
  Polytope P
  Returns
  Polytope
  
  Example:
  Consider this triangle not containing the origin:> $P = new Polytope(VERTICES => [[1,1,1],[1,2,1],[1,1,2]]);> $origin = new Vector([1,0,0]);> print $PC->contains_in_interior($origin); To create a translate that contains the origin, do this:> $PC = center($P);> print $PC->contains_in_interior($origin); 1 This is what happened to the vertices:> print $PC->VERTICES; 1 -1/3 -1/3 1 2/3 -1/3 1 -1/3 2/3 There also exists a property to check whether a polytope is centered:> print $PC->CENTERED; 1
- orthantify (P, v) → Polytope
  
  Make a polyhedron POSITIVE. Apply an affine transformation to a polyhedron such that the vertex v is mapped to the origin (1,0,...,0) and as many facets through this vertex as possible are mapped to the bounding facets of the first orthant.
  Parameters
  Polytope P
  Int v
  vertex to be moved to the origin. By default it is the first affine vertex of the polyhedron.
  Returns
  Polytope
  
  Example:
  To orthantify the square, moving its first vertex to the origin, do this:> $p = orthantify(cube(2),1);> print $p->VERTICES; 1 2 0 1 0 0 1 2 2 1 0 2
- polarize (C) → Cone
  
  Given a bounded, centered, not necessarily full-dimensional polytope P, produce its polar with respect to the standard Euclidean scalar product. Note that the definition of the polar has changed after version 2.10: the polar is reflected in the origin to conform with cone polarization If P is not full-dimensional, the output will contain lineality orthogonal to the affine span of P. In particular, polarize() of a pointed polytope will always produce a full-dimensional polytope. If you want to compute the polar inside the affine hull you may use the pointed_part client afterwards.
  Parameters
  Cone C
  Options
  Bool no_coordinates
  only combinatorial information is handled
  Returns
  Cone
  
  Example:
  To save the polar of the square in the variable $p and then print its vertices, do this:> $p = polarize(cube(2));> print $p->VERTICES; 1 1 0 1 -1 0 1 0 1 1 0 -1
- revert (P) → Polytope
  
  Apply a reverse transformation to a given polyhedron P. All transformation clients keep track of the polytope's history. They write or update the attachment REVERSE_TRANSFORMATION.
  Applying revert to the transformed polytope reconstructs the original polytope.
  Parameters
  Polytope P
  a (transformed) polytope
  Returns
  Polytope
  the original polytope
  
  Example:
  The following translates the square and then reverts the transformation:> $v = new Vector(1,2);> $p = translate(cube(2),$v);> print $p->VERTICES; 1 0 1 1 2 1 1 0 3 1 2 3> $q = revert($p);> print $q->VERTICES; 1 -1 -1 1 1 -1 1 -1 1 1 1 1
- scale (P, factor, store) → Polytope
  
  Scale a polyhedron P by a given scaling parameter factor.
  Parameters
  Polytope P
  the polyhedron to be scaled
  Scalar factor
  the scaling factor
  Bool store
  stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION); default value: 1.
  Returns
  Polytope
  
  Example:
  To sacle the square by 23, do this:> $p = scale(cube(2),23);> print $p->VERTICES; 1 -23 -23 1 23 -23 1 -23 23 1 23 23 The transformation matrix is stored in an attachment:> print $p->get_attachment('REVERSE_TRANSFORMATION'); 1 0 0 0 1/23 0 0 0 1/23 To reverse the transformation, you can use the revert function.> $q = revert($p);> print $q->VERTICES; 1 -1 -1 1 1 -1 1 -1 1 1 1 1
- transform (P, trans, store) → Polytope
  
  Transform a polyhedron P according to the linear transformation trans.
  Parameters
  Polytope P
  the polyhedron to be transformed
  Matrix trans
  the transformation matrix
  Bool store
  stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION); default value: 1.
  Returns
  Polytope
  
  Example:
  This translates the square by (23,23) and stores the transformation:> $M = new Matrix([1,23,23],[0,1,0],[0,0,1]);> $p = transform(cube(2),$M,1);> print $p->VERTICES; 1 22 22 1 24 22 1 22 24 1 24 24 To retrieve the attached transformation, use this:> print $p->get_attachment('REVERSE_TRANSFORMATION'); 1 -23 -23 0 1 0 0 0 1 Check out the revert function to learn how to undo the transformation. It might have been more comfortable to use the translate function to achieve the above result.
- translate (P, trans, store) → Polytope
  
  Translate a polyhedron P by a given translation vector trans.
  Parameters
  Polytope P
  the polyhedron to be translated
  Vector trans
  the translation vector
  Bool store
  stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION); default value: 1.
  Returns
  Polytope
  
  Example:
  This translates the square by (23,23) and stores the transformation:> $t = new Vector(23,23);> $p = translate(cube(2),$t);> print $p->VERTICES; 1 22 22 1 24 22 1 22 24 1 24 24 To retrieve the attached transformation, use this:> print $p->get_attachment('REVERSE_TRANSFORMATION'); 1 -23 -23 0 1 0 0 0 1 Check out the revert function to learn how to undo the transformation.
- vertex_lattice_normalization (p) → Polytope
  
  Transform to a full-dimensional polytope while preserving the lattice spanned by vertices induced lattice of new vertices = Z^dim
  Parameters
  Polytope p
  the input polytope,
  Options
  Bool store_transform
  store the reverse transformation as an attachement
  Returns
  Polytope
  - the transformed polytope defined by its vertices. Facets are only written if available in p.

Triangulations, subdivisions and volume

These functions collect information about triangulations and other subdivisions of the object and properties usually computed from such, as the volume.

barycentric_subdivision (c) → topaz::SimplicialComplex

Create a simplicial complex as a barycentric subdivision of a given cone or polytope. Each vertex in the new complex corresponds to a face in the old complex.
Parameters
Cone c
input cone or polytope
Options
Bool relabel
generate vertex labels from the faces of the original complex; default true
Bool geometric_realization
create a topaz::GeometricSimplicialComplex; default is true
Returns
topaz::SimplicialComplex

barycentric_subdivision (pc) → PointConfiguration

Create a simplicial complex as the barycentric subdivision of a given point configuration. Each vertex in the new complex corresponds to a face in the old complex.

Parameters

PointConfiguration

input point configuration

Options

Bool	relabel	generate vertex labels from the faces of the original complex; default true
Bool	geometric_realization	read POINTS of the input complex, compute the coordinates of the new vertices and store them as POINTS of the produced complex; default false

Returns

PointConfiguration

coherency_index (p1, p2, points, w1, w2)

DOC_FIXME: Incomprehensible description! Computes the coherency index of w1 w.r.t. w2
Contained in extension bundled:local.
Parameters
Polytope p1
Polytope p2
Matrix points
Vector w1
Vector w2
coherency_index (points, w1, w2)

DOC_FIXME: Incomprehensible description! Computes the coherency index of w1 w.r.t. w2
Contained in extension bundled:local.
Parameters
Matrix points
Vector w1
Vector w2
coherency_index (p1, p2)

DOC_FIXME: Erroneous description! w1 is not a parameter here! Computes the coherency index of p1 w.r.t. p2
Contained in extension bundled:local.
Parameters
Polytope p1
Polytope p2
common_refinement (points, sub1, sub2, dim) → IncidenceMatrix
Computes the common refinement of two subdivisions of points. It is assumed that there exists a common refinement of the two subdivisions.
Parameters
Matrix points
IncidenceMatrix sub1
first subdivision
IncidenceMatrix sub2
second subdivision
Int dim
dimension of the point configuration
Returns
IncidenceMatrix
the common refinement
Example:
A simple 2-dimensional set of points:> $points = new Matrix<Rational>([[1,0,0],[1,1,0],[1,0,1],[1,1,1],[1,2,1]]); Two different subdivisions...> $sub1 = new IncidenceMatrix([[0,1,2],[1,2,3,4]]);> $sub2 = new IncidenceMatrix([[1,3,4],[0,1,2,3]]); ...and their common refinement:> print common_refinement($points,$sub1,$sub2,2); {0 1 2} {1 3 4} {1 2 3}
common_refinement (p1, p2) → Polytope

Computes the common refinement of two subdivisions of the same polytope p1, p2. It is assumed that there exists a common refinement of the two subdivisions. It is not checked if p1 and p2 are indeed the same!
Parameters
Polytope p1
Polytope p2
Returns
Polytope
delaunay_triangulation (V) → Array<Set<Int>>
Compute the Delaunay triangulation of the given SITES of a VoronoiDiagram V. If the sites are not in general position, the non-triangular facets of the Delaunay subdivision are triangulated (by applying the beneath-beyond algorithm).
Parameters
VoronoiDiagram V
Returns
Array<Set<Int>>
Example:
> $VD = new VoronoiDiagram(SITES=>[[1,1,1],[1,0,1],[1,-1,1],[1,1,-1],[1,0,-1],[1,-1,-1]]);> $D = delaunay_triangulation($VD);> print $D; {1 2 4} {2 4 5} {0 1 3} {1 3 4}

foldable_max_signature_ilp (d, points, volume, cocircuit_equations) → LinearProgram<Rational>

Set up an ILP whose MAXIMAL_VALUE is the maximal signature of a foldable triangulation of a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Rational	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Options

filename

a name for a file in .lp format to store the linear program

Returns

LinearProgram<Rational>

an ILP that provides the result

foldable_max_signature_upper_bound (d, points, volume, cocircuit_equations) → Integer

Calculate the LP relaxation upper bound to the maximal signature of a foldable triangulation of polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Rational	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Returns

the optimal value of an LP that provides a bound

interior_and_boundary_ridges (P) → Pair<Array<Set>,Array<Set>>
Find the (d-1)-dimensional simplices in the interior and in the boundary of a d-dimensional polytope or cone
Contained in extension bundled:group.
Parameters
Polytope P
the input polytope or cone
Returns
Pair<Array<Set>,Array<Set>>
Example:
> print interior_and_boundary_ridges(cube(2)); <{0 3} {1 2} > <{0 1} {0 2} {1 3} {2 3} >

is_regular (points, subdiv) → Pair<Bool,Vector>

For a given subdivision subdiv of points tests if the subdivision is regular and if yes computes a weight vector inducing this subdivsion. The output is a pair of Bool and the weight vector. Options can be used to ensure properties of the resulting vector. The default is having 0 on all vertices of the first face of subdiv.

Parameters

Matrix	points	in homogeneous coordinates
Array<Set<Int> >	subdiv

Options

Matrix<Scalar>	equations	system of linear equation the cone is cut with.
Set<Int>	lift_to_zero	gives only lifting functions lifting the designated vertices to 0
Int	lift_face_to_zero	gives only lifting functions lifting all vertices of the designated face to 0

Returns

Pair<Bool,Vector>

Example:

A regular subdivision of the square, with the first cell lifted to zero:> $points = cube(2)->VERTICES;> print is_regular($points,[[0,1,3],[1,2,3]],lift_to_zero=>[0,1,3]); 1 <0 0 1 0>

is_subdivision (points, faces)
Checks whether faces forms a valid subdivision of points, where points is a set of points, and faces is a collection of subsets of (indices of) points. If the set of interior points of points is known, this set can be passed by assigning it to the option interior_points. If points are in convex position (i.e., if they are vertices of a polytope), the option interior_points should be set to [ ] (the empty set).
Parameters
Matrix points
Array<Set<Int>> faces
Options
Set<Int> interior_points
Example:
Two potential subdivisions of the square without innter points:> $points = cube(2)->VERTICES;> print is_subdivision($points,[[0,1,3],[1,2,3]],interior_points=>[ ]); 1> print is_subdivision($points,[[0,1,2],[1,2]],interior_points=>[ ]);
iterated_barycentric_subdivision (c, n) → topaz::SimplicialComplex

Create a simplicial complex as an iterated barycentric subdivision of a given cone or polytope.
Parameters
Cone c
input cone or polytope
Int n
how many times to subdivide
Options
Bool relabel
write labels of new points; default is false
Bool geometric_realization
create a topaz::GeometricSimplicialComplex; default is false
Returns
topaz::SimplicialComplex
max_interior_simplices (P) → Array<Set>
Find the maximal interior simplices of a polytope P. Symmetries of P are NOT taken into account.
Contained in extension bundled:group.
Parameters
Polytope P
the input polytope
Returns
Array<Set>
Example:
> print max_interior_simplices(cube(2)); {0 1 2} {0 1 3} {0 2 3} {1 2 3}
max_interior_simplices (P)

find the maximal interior simplices of a point configuration that DO NOT contain any point in their closure, except for the vertices. Symmetries of the configuration are NOT taken into account.
Contained in extension bundled:group.
Parameters
PointConfiguration P
the input point configuration
metric2hyp_triang (FMS) → Polytope

Given a generic finite metric space FMS, construct the associated (i.e. dual) triangulation of the hypersimplex.
Parameters
TightSpan FMS
Returns
Polytope
metric2splits (D) → Array<Pair<Set>>

Computes all non-trivial splits of a metric space D (encoded as a symmetric distance matrix).
Parameters
Matrix D
Returns
Array<Pair<Set>>
each split is encoded as a pair of two sets.
mixed_volume (P1, P2, Pn) → Scalar
Produces the mixed volume of polytopes P₁,P₂,...,P_n.
Parameters
Polytope<Scalar> P1
first polytope
Polytope<Scalar> P2
second polytope
Polytope<Scalar> Pn
last polytope
Returns
Scalar
mixed volume
Example:
> print mixed_volume(cube(2),simplex(2)); 4
n_triangulations (M, optimization) → Integer
Calculates the number of triangulations of the input points given as rows of a matrix. This can be space intensive.
Parameters
Matrix M
points in the projective plane
Bool optimization
defaults to 1, where 1 includes optimization and 0 excludes it
Returns
Integer
number of triangulations
Example:
To print the number of possible triangulations of a square, do this:> print n_triangulations(cube(2)->VERTICES); 2
placing_triangulation (Points) → Array<Set<Int>>
Compute the placing triangulation of the given point set using the beneath-beyond algorithm.
Parameters
Matrix Points
the given point set
Options
Bool non_redundant
whether it's already known that Points are non-redundant
Array<Int> permutation
placing order of Points, must be a valid permutation of (0..Points.rows()-1)
Returns
Array<Set<Int>>
Example:
To compute the placing triangulation of the square (of whose vertices we know that they're non-redundant), do this:> $t = placing_triangulation(cube(2)->VERTICES,non_redundant=>1);> print $t; {0 1 2} {1 2 3}
points2metric (points) → Matrix
Define a metric by restricting the Euclidean distance function to a given set of points. Due to floating point computations (sqrt is used) the metric defined may not be exact. If the option max or l1 is set to true the max-norm or l1-norm is used instead (with exact computation).
Parameters
Matrix points
Options
Bool max
triggers the usage of the max-norm (exact computation)
Bool l1
triggers the usage of the l1-norm (exact computation)
Returns
Matrix
Example:
> print points2metric(cube(2),max=>1); 0 2 2 2 2 0 2 2 2 2 0 2 2 2 2 0
poly2metric (P) → Matrix
Define a metric by restricting the Euclidean distance function to the vertex set of a given polytope P. Due to floating point computations (sqrt is used) the metric defined may not be exact. If the option max or l1 is set to true the max-norm or l1-norm is used instead (with exact computation).
Parameters
Polytope P
Options
Bool max
triggers the usage of the max-norm (exact computation)
Returns
Matrix
Example:
> print points2metric(cube(2)->VERTICES,max=>1); 0 2 2 2 2 0 2 2 2 2 0 2 2 2 2 0

quotient_space_simplexity_ilp (d, V, volume, cocircuit_equations) → LinearProgram

Set up an LP whose MINIMAL_VALUE is a lower bound for the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	V	the input points or vertices
Scalar	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Options

filename

a name for a file in .lp format to store the linear program

Returns

LinearProgram

an LP that provides a lower bound

quotient_space_simplexity_lower_bound (d, V, volume, cocircuit_equations) → Integer

Calculate a lower bound for the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	V	the input points or vertices
Scalar	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Returns

the optimal value of an LP that provides a lower bound

regularity_lp (points, subdiv) → Polytope<Scalar>

For a given subdivision subdiv of points determines a LinearProgram to decide whether the subdivision is regular. The output a Polytope with an attached LP. Options can be used to ensure properties of the resulting LP. The default is having 0 on all vertices of the first face of subdiv.

Parameters

Matrix	points	in homogeneous coordinates
Array<Set<Int> >	subdiv

Options

Matrix<Scalar>	equations	system of linear equation the cone is cut with.
Set<Int>	lift_to_zero	gives only lifting functions lifting the designated vertices to 0
Int	lift_face_to_zero	gives only lifting functions lifting all vertices of the designated face to 0
Scalar	epsilon	minimum distance from all inequalities

Returns

Polytope<Scalar>

regular_subdivision (points, weights) → Array<Set<Int>>
Compute a regular subdivision of the polytope obtained by lifting points to weights and taking the lower complex of the resulting polytope. If the weight is generic the output is a triangulation.
Parameters
Matrix points
Vector weights
Returns
Array<Set<Int>>
Example:
The following generates a regular subdivision of the square.> $w = new Vector(2,23,2,2);> $r = regular_subdivision(cube(2)->VERTICES,$w);> print $r; {0 1 3} {0 2 3}

secondary_cone (points, subdiv) → Cone

For a given subdivision subdiv of points tests computes the corresponding secondary cone. If the subdivision is not regular, the cone will be the secondary cone of the finest regular coarsening of subdiv. (See option test_regularity) Options can be used to make the Cone POINTED.

Parameters

Matrix	points	in homogeneous coordinates
Array<Set<Int> >	subdiv

Options

Matrix<Scalar>	equations	system of linear equation the cone is cut with.
Set<Int>	lift_to_zero	gives only lifting functions lifting the designated vertices to 0
Int	lift_face_to_zero	gives only lifting functions lifting all vertices of the designated face to 0
Bool	test_regularity	throws an exception if the subdivision is not regular

Returns

Cone

simplexity_ilp (d, points, the, volume, cocircuit_equations) → LinearProgram

Set up an ILP whose MINIMAL_VALUE is the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Array<Set>	the	representatives of maximal interior simplices
Scalar	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Options

filename

a name for a file in .lp format to store the linear program

Returns

LinearProgram

an LP that provides a lower bound

simplexity_ilp_with_angles (d, points, the, volume, cocircuit_equations) → LinearProgram

Set up an ILP whose MINIMAL_VALUE is the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Array<Set>	the	(representative) maximal interior simplices
Scalar	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Options

filename

a name for a file in .lp format to store the linear program

Returns

LinearProgram

an LP that provides a lower bound

simplexity_lower_bound (d, points, volume, cocircuit_equations) → Integer

Calculate the LP relaxation lower bound for the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Scalar	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Returns

the optimal value of an LP that provides a lower bound

splits (V, G, F, dimension) → Matrix

Computes the SPLITS of a polytope. The splits are normalized by dividing by the first non-zero entry. If the polytope is not fulldimensional the first entries are set to zero unless coords are specified.
Parameters
Matrix V
vertices of the polytope
Graph G
graph of the polytope
Matrix F
facets of the polytope
Int dimension
of the polytope
Options
Set<Int> coords
entries that should be set to zero
Returns
Matrix
splits_in_subdivision (vertices, subdivision, splits) → Set<Int>

Tests which of the splits of a polyhedron are coarsenings of the given subdivision.
Parameters
Matrix vertices
the vertices of the polyhedron
Array<Set<Int>> subdivision
a subdivision of the polyhedron
Matrix splits
the splits of the polyhedron
Returns
Set<Int>
split_compatibility_graph (splits, P) → Graph

DOC_FIXME: Incomprehensible description! Computes the compatibility graph among the splits of a polytope P.
Parameters
Matrix splits
the splits given by split equations
Polytope P
the input polytope
Returns
Graph
split_polyhedron (P) → Polytope

Computes the split polyhedron of a full-dimensional polyhdron P.
Parameters
Polytope P
Returns
Polytope
staircase_weight (k, l) → Vector<Rational>
Gives a weight vector for the staircase triangulation of the product of a k-1- and an l-1-dimensional simplex.
Parameters
Int k
the number of vertices of the first simplex
Int l
the number of vertices of the second simplex
Returns
Vector<Rational>
Example:
The following creates the staircase triangulation of the product of the 2- and the 1-simplex.> $w = staircase_weight(3,2);> $p = product(simplex(2),simplex(1));> $p->POLYTOPAL_SUBDIVISION(WEIGHTS=>$w);> print $p->POLYTOPAL_SUBDIVISION->MAXIMAL_CELLS; {0 2 4 5} {0 1 3 5} {0 2 3 5}
stellar_subdivision (pc, faces) → PointConfiguration

Computes the complex obtained by stellar subdivision of all faces of the TRIANGULATION of the PointConfiguration.
Parameters
PointConfiguration pc
input point configuration
Array<Set<Int>> faces
list of faces to subdivide
Options
Bool no_labels
: do not write any labels
Returns
PointConfiguration

symmetrized_foldable_max_signature_ilp (d, points, volume, generators, symmetrized_foldable_cocircuit_equations) → LinearProgram<Rational>

Set up an ILP whose MAXIMAL_VALUE is the maximal signature of a foldable triangulation of a polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Rational	volume	the volume of the convex hull
Array<Array<Int>>	generators	the generators of the symmetry group
SparseMatrix	symmetrized_foldable_cocircuit_equations	the matrix of symmetrized cocircuit equations

Options

filename

a name for a file in .lp format to store the linear program

Returns

LinearProgram<Rational>

an ILP that provides the result

symmetrized_foldable_max_signature_upper_bound (d, points, volume, cocircuit_equations) → Integer

Calculate the LP relaxation upper bound to the maximal signature of a foldable triangulation of polytope, point configuration or quotient manifold

Contained in extension bundled:group.

Parameters

Int	d	the dimension of the input polytope, point configuration or quotient manifold
Matrix	points	the input points or vertices
Rational	volume	the volume of the convex hull
SparseMatrix	cocircuit_equations	the matrix of cocircuit equations

Returns