Differences

This shows you the differences between two versions of the page.

--- playground:playground [2019/03/14 09:36] – oroehrig
+++ playground:playground [2020/05/21 12:24] (current) – removed benmuell
@@ Line 1: / Line 1: @@
-====== application polytope ======
- This is the historically first application, and the largest one.
- It deals with convex pointed polyhedra.  It allows to define a polyhedron either as a convex hull of a point set, an intersection of
- halfspaces, or as an incidence matrix without any embedding.  Then you can ask for a plenty of its (especially combinatorial)
- properties,  construct new polyhedra by modifying it,  or study the behavior of the objective functions.
- There is a wide range of visualization methods for polyhedra, even for dimensions > 4 and purely combinatorial descriptions,
- including interfaces to interactive geometry viewers (such as [[wiki:external_software#JavaView|JavaView]] or [[wiki:external_software#geomview|geomview]]), generating
- PostScript drawings and povray scene files.
-imports from ['graph', 'common']
-uses ['ideal', 'topaz', 'group']
-===== Objects =====
-  * [[polytope:AffineLattice|AffineLattice]]:\\  a lattice that is displaced from the origin, i.e., a set of the form x + L, where x is a non-zero vector and L a (linear) lattice
-  * [[polytope:Cone|Cone]]:\\  A polyhedral cone, not necessarily pointed. Note that in contrast to the vertices of a polytope, the [[/polytope/objects/Cone/properties/Geometry/RAYS]] are given in affine coordinates.
-  * [[polytope:GroebnerBasis|GroebnerBasis]]:\\  The Groebner basis of the homogeneous toric ideal associated to the polytope, the term order is given in matrix form.
-  * [[polytope:LinearProgram|LinearProgram]]:\\  A linear program specified by a linear or abstract objective function
-  * [[polytope:MixedIntegerLinearProgram|MixedIntegerLinearProgram]]:\\  A mixed integer linear program specified by a linear or abstract objective function
-  * [[polytope:PointConfiguration|PointConfiguration]]:\\  The [[/polytope/objects/PointConfiguration/properties/Input property/POINTS]] of an object of type PointConfiguration encode a not necessarily convex finite point set. The difference to a parent [[/polytope/objects/Geometry/VectorConfiguration]] is that the points have homogeneous coordinates, i.e. they will be normalized to have first coordinate 1 without warning.
-  * [[polytope:Polytope|Polytope]]:\\  Not necessarily bounded convex polyhedron, i.e., the feasible region of a linear program. Nonetheless, the name "Polytope" is used for two reasons: Firstly, as far as the combinatorics is concerned we always deal with polytopes; see the description of [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] for details. Note that a pointed polyhedron is projectively equivalent to a polytope. The second reason is historical. We use homogeneous coordinates, which is why Polytope is derived from [[/polytope/objects/Cone]].
-  * [[polytope:PropagatedPolytope|PropagatedPolytope]]:\\  Polytope propagation means to define a polytope inductively by assigning vectors to arcs of a directed graph.  At each node of such a graph a polytope arises as the joint convex hull of the polytopes at the translated sources of the inward pointing arcs. For details see        Joswig: Polytope Propagation on Graphs.       Chapter 6 in        Pachter/Sturmfels: Algebraic Statistics for Computational Biology, Cambridge 2005.
-  * [[polytope:QuotientSpace|QuotientSpace]]:\\  A topological quotient space obtained from a [[/polytope/objects/Polytope]] by identifying faces. This object will sit inside the polytope.
-  * [[polytope:SchlegelDiagram|SchlegelDiagram]]:\\  A Schlegel diagram of a polytope.
-  * [[polytope:SymmetrizedCocircuitEquations|SymmetrizedCocircuitEquations]]:\\
-  * [[polytope:VectorConfiguration|VectorConfiguration]]:\\  An object of type VectorConfiguration deals with properties of row vectors, assembled into an n x d matrix called [[/polytope/objects/Geometry/VectorConfiguration/properties/Input property/VECTORS]].  The entries of these row vectors are interpreted as non-homogeneous coordinates.  In particular, the coordinates of a VECTOR will *NOT* be normalized to have a leading 1.
-  * [[polytope:Visual::Cone|Visual::Cone]]:\\  Visualization of a Cone as a graph (if 1d), or as a solid object (if 2d or 3d)
-  * [[polytope:Visual::Gale|Visual::Gale]]:\\  A gale diagram prepared for drawing.
-  * [[polytope:Visual::PointConfiguration|Visual::PointConfiguration]]:\\  Visualization of the point configuration.
-  * [[polytope:Visual::Polytope|Visual::Polytope]]:\\  Visualization of a polytope as a graph (if 1d), or as a solid object (if 2d or 3d), or as a Schlegel diagram (4d).
-  * [[polytope:Visual::PolytopeGraph|Visual::PolytopeGraph]]:\\  Visualization of the graph of a polyhedron.
-  * [[polytope:Visual::PolytopeLattice|Visual::PolytopeLattice]]:\\  Visualization of the [[/polytope/objects/Polytope/properties/Combinatorics/HASSE_DIAGRAM]] of a polyhedron as a multi-layer graph..
-  * [[polytope:Visual::SchlegelDiagram|Visual::SchlegelDiagram]]:\\  Visualization of the Schlegel diagram of a polytope.
-  * [[polytope:VoronoiPolyhedron|VoronoiPolyhedron]]:\\  For a finite set of [[/polytope/objects/VoronoiPolyhedron/properties/SITES]] //S// the Voronoi region of each site is the set of points closest (with respect to Euclidean distance) to the given site.  All Voronoi regions (and their faces) form a polyhedral complex which is a vertical projection of the boundary complex of an unbounded polyhedron P(S).  This way VoronoiPolyhedron becomes a derived class from [[]].
-===== Functions =====
-----
-==== Combinatorics ====
- These functions capture combinatorial information of the object.
- Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice.
-{{anchor:deletion(VectorConfiguration C, Int v):}} **''deletion(VectorConfiguration C, Int v)''**
-  * //Parameters:
-/polytope/objects/Geometry/VectorConfiguration ''C'' : \\ /common/property_types/Basic Types/Int ''v'' : index of the vector to delete
-\\
-  *      Delete a specified vector //v// from a vector configuration //C//.
-{{anchor:cocircuit_equation_of_ridge(Cone C, Set rho):}} **''cocircuit_equation_of_ridge(Cone C, Set rho)''**
-  * //Parameters:
-/polytope/objects/Cone ''C'' : \\ /common/property_types/Set Types/Set ''rho'' : the interior ridge
-\\
-  * //Returns:// /common/property_types/Set Types/HashMap</common/property_types/Set Types/Set,/common/property_types/Basic Types/Rational>
-  *      The cocircuit equations of a cone C corresponding to some interior ridge rho\\     with respect to a list of interior simplices\\     symmetries of the cone are NOT taken into account
-{{anchor:contraction(VectorConfiguration C, Int v):}} **''contraction(VectorConfiguration C, Int v)''**
-  * //Parameters:
-/polytope/objects/Geometry/VectorConfiguration ''C'' : \\ /common/property_types/Basic Types/Int ''v'' : index of the vector to contract
-\\
-  *      Contract a vector configuration //C// along a specified vector //v//.
-{{anchor:cocircuit_equations(Cone C, Set> interior_ridge_simplices, Set> interior_simplices):}} **''cocircuit_equations(Cone C, Set> interior_ridge_simplices, Set> interior_simplices)''**
-  * //Parameters:
-/polytope/objects/Cone ''C'' : \\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set> ''interior_ridge_simplices'' : interior codimension 1 simplices
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set> ''interior_simplices'' : interior simplices of maximal dimension
-\\
-  * //Returns:// /common/property_types/Algebraic Types/SparseMatrix</common/property_types/Basic Types/Int>
-  *      A matrix whose rows contain the cocircuit equations of a cone C\\     with respect to a list of interior ridge simplices\\     symmetries of the cone are NOT taken into account
-{{anchor:codegree:}} **''codegree''**
-{{anchor:circuits2matrix(Int>>> co):}} **''circuits2matrix(Int>>> co)''**
-  * //Parameters:
-/common/property_types/Set Types/Set</common/property_types/Basic Types/Pair</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>,/common/property_types/Set Types/Set</common/property_types/Basic Types/Int>>> ''co'' : /circuits a set of circuits or cocircuits
-\\
-  * //Returns:// /common/property_types/Algebraic Types/SparseMatrix</common/property_types/Basic Types/Rational>
-  *      Convert [[/polytope/objects/Polytope/properties/Matroid properties/CIRCUITS]] or [[/polytope/objects/Polytope/properties/Matroid properties/COCIRCUITS]] to a 0/+1/-1 matrix, with one row for each circuit/cocircuit, \\     and as many columns as there are VECTORs/POINTS.
-{{anchor:degree<Scalar>:}} **''degree<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : the underlying number type,
-  *      Calculate the degree of a cone, polytope or point configuration P.\\     This is the maximal dimension of an interior face of P,\\     where an interior face is a subset of the points of P whose convex hull does not lie on the boundary of P.\\     Moreover, the relation degree(P) + codegree(P) = dim(P) + 1 holds.
-  * //Example://\\ To find the degree of the 3-cube, type \\ <code> >  print degree(cube(3));
-</code>
-----
-==== Comparing ====
- Functions based on graph isomorphisms.
-{{anchor:equal_polyhedra(Polytope P1, Polytope P2):}} **''equal_polyhedra(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : the first polytope
-\\ /polytope/objects/Polytope ''P2'' : the second polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *
-  * //Example://\\  \\ <code> >  $p = new Polytope(VERTICES => [[1,-1,-1],[1,1,-1],[1,-1,1],[1,1,1]]);
- print equal_polyhedra($p,cube(2));
- true
-</code>\\  To see why two polytopes are unequal, try this: \\ <code> >  print equal_polyhedra($p,cube(3),verbose => 1);
- Cones/Polytopes do no live in the same ambient space.
- false
-</code>\\  \\ <code> >  print equal_polyhedra($p,simplex(2),verbose => 1);
- Inequality 1 -1 -1 not satisfied by point 1 1 1.
- false
-</code>
-{{anchor:isomorphic(Cone P1, Cone P2):}} **''isomorphic(Cone P1, Cone P2)''**
-  * //Parameters:
-/polytope/objects/Cone ''P1'' : the first cone/polytope
-\\ /polytope/objects/Cone ''P2'' : the second cone/polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Check whether the face lattices of two cones or polytopes are isomorphic.\\     The problem is reduced to graph isomorphism of the vertex-facet incidence graphs.
-  * //Example://\\ The following compares the standard 2-cube with a polygon generated as the convex hull of five points.  The return value is true since both polygons are quadrangles. \\ <code> >  $p = new Polytope(POINTS=>[[1,-1,-1],[1,1,-1],[1,-1,1],[1,1,1],[1,0,0]]);
- print isomorphic(cube(2),$p);
- true
-</code>
-{{anchor:included_polyhedra(Polytope P1, Polytope P2):}} **''included_polyhedra(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : the first polytope
-\\ /polytope/objects/Polytope ''P2'' : the second polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *
-  * //Example://\\  \\ <code> >  print included_polyhedra(simplex(3),cube(3));
- true
-</code>\\  To see in what way the two polytopes differ, try this: \\ <code> >  print included_polyhedra(cube(2),cube(3),verbose=>1);
- Cones/Polytopes do no live in the same ambient space.
- false
-</code>
-{{anchor:find_facet_vertex_permutations(Cone P1, Cone P2):}} **''find_facet_vertex_permutations(Cone P1, Cone P2)''**
-  * //Parameters:
-/polytope/objects/Cone ''P1'' : the first cone/polytope
-\\ /polytope/objects/Cone ''P2'' : the second cone/polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Pair</common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>, /common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>>
-  *      Find the permutations of facets and vertices which maps the cone or polyhedron //P1// to //P2//.\\     The facet permutation is the first component, the vertex permutation is the second component of the return value.\\    \\     Only the combinatorial isomorphism is considered.\\     If the polytopes are not isomorphic, an exception is thrown.
-  * //Example://\\ To print the vertex permutation that maps the 3-simplex to its mirror image, type this: \\ <code> >  $p = find_facet_vertex_permutations(simplex(3),scale(simplex(3),-1));
- print $p->first;
-2 3 0
-</code>
-{{anchor:congruent(Polytope P1, Polytope P2):}} **''congruent(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : the first polytope
-\\ /polytope/objects/Polytope ''P2'' : the second polytope
-\\
-  * //Returns:// /polytope/functions/Comparing/congruent/tparams/Scalar
-  *      Check whether two given polytopes //P1// and //P2// are congruent, i.e. whether\\     there is an affine isomorphism between them that is induced by a (possibly scaled) orthogonal matrix.\\     Returns the scale factor, or 0 if the polytopes are not congruent.\\    \\     We are using the reduction of the congruence problem (for arbitrary point sets) to the graph\\     isomorphism problem due to:\\    	 Akutsu, T.: On determining the congruence of point sets in `d` dimensions.\\    	 Comput. Geom. Theory Appl. 9, 247--256 (1998), no. 4
-  * //Example://\\ Let's first consider an isosceles triangle and its image of the reflection in the origin: \\ <code> >  $t = simplex(2);
- $tr = simplex(2,-1);
-</code>\\  Those two are congruent: \\ <code> >  print congruent($t,$tr);
-</code>\\  If we scale one of them, we get a factor: \\ <code> >  print congruent(scale($t,2),$tr);
-</code>\\  But if we instead take a triangle that is not isosceles, we get a negative result. \\ <code> >  $tn = new Polytope(VERTICES => [[1,0,0],[1,2,0],[1,0,1]]);
- print congruent($t,$tn);
-</code>
-{{anchor:lattice_isomorphic_smooth_polytopes(Polytope P1, Polytope P2):}} **''lattice_isomorphic_smooth_polytopes(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : the first lattice polytope
-\\ /polytope/objects/Polytope ''P2'' : the second lattice polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Tests whether two smooth lattice polytopes are lattice equivalent\\     by comparing lattice distances between vertices and facets.
-  * //Example://\\  \\ <code> >  $t = new Vector(2,2);
- print lattice_isomorphic_smooth_polytopes(cube(2),translate(cube(2),$t));
- true
-</code>
-----
-==== Consistency check ====
- These functions are for checking the consistency of some properties.
-{{anchor:check_poly(IncidenceMatrix VIF):}} **''check_poly(IncidenceMatrix VIF)''**
-  * //Parameters:
-/common/property_types/Set Types/IncidenceMatrix ''VIF'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Try to check whether a given vertex-facet incidence matrix //VIF// defines a polytope.\\     Note that a successful certification by check_poly is **not sufficient**\\     to determine whether an incidence matrix actually defines a polytope.\\     Think of it as a plausibility check.
-{{anchor:validate_moebius_strip_quads(Polytope P):}} **''validate_moebius_strip_quads(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the given polytope
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Int>
-  *      Checks whether the [[/polytope/objects/Polytope/properties/Combinatorics/MOEBIUS_STRIP_QUADS|MOEBIUS_STRIP_QUADS]]\\     form a Moebius strip with parallel opposite edges.\\     Prints a message to stdout and\\     returns the [[/polytope/objects/Polytope/properties/Combinatorics/MOEBIUS_STRIP_EDGES|MOEBIUS_STRIP_EDGES]]\\     if the answer is affirmative.
-{{anchor:check_inc(Matrix points, Matrix hyperplanes, String sign, Bool verbose):}} **''check_inc(Matrix points, Matrix hyperplanes, String sign, Bool verbose)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : \\ /common/property_types/Algebraic Types/Matrix ''hyperplanes'' : \\ /common/property_types/Basic Types/String ''sign'' : composed of one or two characters from [-+0], representing the
-  allowed domain of the vector inner products.
-\\ /common/property_types/Basic Types/Bool ''verbose'' : print all products violating the required relation
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Check coordinate data. For each pair of vectors from two given matrices\\     their inner product must satisfy the given relation.
-  * //Example://\\ Let's check which vertices of the square lie in its zeroth facet: \\ <code> >  $H = cube(2)->FACETS->minor([0],All);
- print check_inc(cube(2)->VERTICES,$H,'0',1);
- <1,0>   ( 1 1 -1 ) * [ 1 1 0 ] == 2
- <3,0>   ( 1 1 1 ) * [ 1 1 0 ] == 2
- #points==4, #hyperplanes==1, -:0, 0:2, +:2, total:4
- false
-</code>\\  Thus, the first and third vertex don't lie on the hyperplane defined by the facet but on the positive side of it, and the remaining two lie on the hyperplane. \\
-{{anchor:validate_moebius_strip(Polytope P):}} **''validate_moebius_strip(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the given polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Validates the output of the client [[/polytope/functions/Other/edge_orientable]],\\     in particular it checks whether the [[/polytope/objects/Polytope/properties/Combinatorics/MOEBIUS_STRIP_EDGES|MOEBIUS_STRIP_EDGES]]\\     form a Moebius strip with parallel opposite edges.\\     Prints a message to stdout.
-----
-==== Coordinate conversions ====
- The following functions allow for the conversion of the coordinate type of cones and polytopes.
-{{anchor:affine_float_coords(Polytope P):}} **''affine_float_coords(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : source object
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Float>
-  *      Dehomogenize the [[/polytope/objects/Polytope/properties/Geometry/VERTICES|vertex coordinates]] and convert them to Float
-  * //Example://\\  \\ <code> >  print cube(2,1/2)->VERTICES;
--1/2 -1/2
-1/2 -1/2
--1/2 1/2
-1/2 1/2
-</code>\\  \\ <code> >  print affine_float_coords(cube(2,1/2));
- -0.5 -0.5
-.5 -0.5
- -0.5 0.5
-.5 0.5
-</code>
-{{anchor:convert_to:}} **''convert_to''**
-----
-==== Finite metric spaces ====
- Tight spans and their connections to polyhedral geometry
-{{anchor:tight_span_envelope(SubdivisionOfPoints sd):}} **''tight_span_envelope(SubdivisionOfPoints sd)''**
-  * //Parameters:
-/fan/objects/Geometry/SubdivisionOfPoints ''sd'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Computes the envelope for a given subdivision of points.
-----
-==== Geometry ====
- These functions capture geometric information of the object.
- Geometric properties depend on geometric information of the object, like, e.g., vertices or facets.
-{{anchor:induced_lattice_basis(Polytope p):}} **''induced_lattice_basis(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : the input polytope
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Integer>
-  *      Returns a basis of the affine lattice spanned by the vertices
-  * //Example://\\ The vertices of the 2-simplex span all of Z^2... \\ <code> >  print induced_lattice_basis(simplex(2));
-1 0
-0 1
-</code>\\  ...but if we scale it with 2, we get only every second lattice point. \\ <code> >  print induced_lattice_basis(scale(simplex(2),2));
-2 0
-0 2
-</code>
-{{anchor:normaliz_compute(Cone C):}} **''normaliz_compute(Cone C)''**
-  * //Parameters:
-/polytope/objects/Cone ''C'' : \\
-  * //Returns:// /common/property_types/Basic Types/List
-  *      Compute degree one elements, Hilbert basis or Hilbert series of a cone C with libnormaliz\\     Hilbert series and Hilbert h-vector depend on the given grading\\     and will not work unless C is [[/polytope/objects/Cone/properties/Lattice points in cones/HOMOGENEOUS]] or a [[/polytope/objects/Cone/properties/Lattice points in cones/MONOID_GRADING]] is set
-{{anchor:zonotope_tiling_lattice(Polytope P):}} **''zonotope_tiling_lattice(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the zonotope
-\\
-  * //Returns:// /polytope/objects/Geometry/AffineLattice
-  *      Calculates a generating set for a tiling lattice for P, \\     i.e., a lattice L such that P + L tiles the affine span of P.
-  * //Example://\\ This determines a tiling lattice for a parallelogram with the origin as its vertex barycenter and prints it base vectors: \\ <code> >  $M = new Matrix([[1,1,0],[1,1,1]]);
- $p = zonotope($M);
- $A = zonotope_tiling_lattice($p);
- print $A->BASIS;
--1 -1
-0 1
-</code>
-{{anchor:visible_face_indices(Cone P, Vector q):}} **''visible_face_indices(Cone P, Vector q)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Algebraic Types/Vector ''q'' : \\
-  * //Returns:// /common/property_types/Set Types/Set
-  *      Return the indices (in the HASSE_DIAGRAM) of all faces that are visible from a point //q//.
-  * //Example://\\ This prints the faces of a square with the origin as its center and side length 2 that are visible from a certain point: \\ <code> >  $p = cube(2);
- $v = new Vector([1,2,2]);
- map { print $p->HASSE_DIAGRAM->FACES->[$_], "\n" } @{visible_face_indices($p,$v)};
- {}
- {1}
- {2}
- {3}
- {1 3}
- {2 3}
-</code>
-{{anchor:circuit_completions(Matrix L, Matrix R):}} **''circuit_completions(Matrix L, Matrix R)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''L'' : \\ /common/property_types/Algebraic Types/Matrix ''R'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Set Types/Set>
-  *      Given two matrices L (n x d) and R (m x d) such that (L/R) has rank r, select all (r+1-n)-subsets C of rows of R such that (L,S) or (S,L) is a circuit.\\     Optionally, if d > r, a basis H for the orthogonal span of the affine hull of (L/R) may be given.
-  * //Example://\\ Divide the vertex set of the 3-cube into a body diagonal L and six remaining vertices R. To find the subsets of R that complete L to a circuit, type \\ <code> >  $c = cube(3);
- $L = $c->VERTICES->minor([0,7],All);
- $R = $c->VERTICES->minor([1,2,3,4,5,6],All);
- print circuit_completions($L,$R);
- {0 1 3}
- {2 4 5}
-</code>
-{{anchor:minimal_vertex_angle(Polytope P):}} **''minimal_vertex_angle(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Basic Types/Float
-  *      Computes the minimal angle between two vertices of the input polytope //P//.
-  * //Example://\\  \\ <code> >  print minimal_vertex_angle(simplex(3));
-.14159265358979
-</code>
-{{anchor:separable(Vector q, Cone P):}} **''separable(Vector q, Cone P)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector ''q'' : the vertex (candidate) which is to be separated from //P//
-\\ /polytope/objects/Cone ''P'' : the polytope/cone from which //q// is to be separated
-\\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Checks whether there exists a hyperplane separating a given point //q//\\     from a polytope/cone //P// by solving a suitable LP.\\     If true, //q// is a vertex of the polytope defined by //q// and the vertices of //P//.\\     To get the separating hyperplane, use __separating_hyperplane__.\\     Works without knowing the facets of P!
-  * //Example://\\  \\ <code> >  $q = cube(2)->VERTICES->row(0);
- print separable(cube(2), $q, strong=>0);
- true
-</code>
-{{anchor:all_steiner_points(Polytope P):}} **''all_steiner_points(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Compute the Steiner points of all faces of a polyhedron //P// using a\\     randomized approximation of the angles.\\     //P// must be [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]].
-{{anchor:visible_facet_indices(Cone P, Vector q):}} **''visible_facet_indices(Cone P, Vector q)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Algebraic Types/Vector ''q'' : \\
-  * //Returns:// /common/property_types/Set Types/Set
-  *      Return the indices of all facets that are visible from a point //q//.
-  * //Example://\\ This prints the facets of a square with the origin as its center and side length 2 that are visible from a certain point: \\ <code> >  $p = cube(2);
- $v = new Vector([1,2,2]);
- map { print $p->VERTICES_IN_FACETS->[$_], "\n" } @{visible_facet_indices($p,$v)};
- {1 3}
- {2 3}
-</code>
-{{anchor:integer_points_bbox(Scalar> P):}} **''integer_points_bbox(Scalar> P)''**
-  * //Parameters:
-/polytope/objects/Polytope</polytope/functions/Geometry/integer_points_bbox/tparams/Scalar> ''P'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Integer>
-  *      Enumerate all integer points in the given polytope by searching a bounding box.
-  * //Example://\\  \\ <code> >  $p = new Polytope(VERTICES=>[[1,13/10,1/2],[1,1/5,6/5],[1,1/10,-3/2],[1,-7/5,1/5]]);
- print integer_points_bbox($p);
-0 -1
--1 0
-0 0
-1 0
-0 1
-</code>
-{{anchor:dihedral_angle(Scalar> H1, Scalar> H2):}} **''dihedral_angle(Scalar> H1, Scalar> H2)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector</polytope/functions/Geometry/dihedral_angle/tparams/Scalar> ''H1'' : : first hyperplane
-\\ /common/property_types/Algebraic Types/Vector</polytope/functions/Geometry/dihedral_angle/tparams/Scalar> ''H2'' : : second hyperplane
-\\
-  * //Returns:// /common/property_types/Basic Types/Float
-  *      Compute the dihedral angle between two (oriented) affine or linear hyperplanes.
-  * //Example://\\  \\ <code> >  $H1 = new Vector(1,5,5);
- $H2 = new Vector(1,-5,5);
- print dihedral_angle($H1,$H2,deg=>1);
-</code>
-{{anchor:print_face_lattice(IncidenceMatrix VIF, Bool dual):}} **''print_face_lattice(IncidenceMatrix VIF, Bool dual)''**
-  * //Parameters:
-/common/property_types/Set Types/IncidenceMatrix ''VIF'' : \\ /common/property_types/Basic Types/Bool ''dual'' : \\
-  *      Write the face lattice of a vertex-facet incidence matrix //VIF// to stdout.\\     If //dual// is set true the face lattice of the dual is printed.
-  * //Example://\\ To get a nice representation of the squares face lattice, do this: \\ <code> >  print_face_lattice(cube(2)->VERTICES_IN_FACETS);
- FACE_LATTICE
- [ -1 : 4 ]
- {{0 1} {0 2} {1 3} {2 3}}
- [ -2 : 4 ]
- {{0} {1} {2} {3}}
-</code>
-{{anchor:occluding_cone(Cone P, Set F):}} **''occluding_cone(Cone P, Set F)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Set Types/Set ''F'' : \\
-  * //Returns:// /polytope/objects/Cone
-  *      For a face //F// of a cone or polytope //P//, return the polyhedral cone //C// such that\\     taking the convex hull of //P// and any point in //C// destroys the face //F//
-  * //Example://\\ To find the occluding cone of an edge of the 3-cube, type \\ <code> >  $c=occluding_cone(cube(3), [0,1]);
- print $c->FACETS;
- -1 0 -1 0
- -1 0 0 -1
-</code>
-{{anchor:steiner_point(Polytope P):}} **''steiner_point(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/Vector
-  *      Compute the Steiner point of a polyhedron //P// using a randomized\\     approximation of the angles.
-{{anchor:containing_outer_cone(Polytope P, Vector q):}} **''containing_outer_cone(Polytope P, Vector q)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Algebraic Types/Vector ''q'' : \\
-  * //Returns:// /common/property_types/Set Types/Set
-  *      Return the vertices of the face of P whose outer cone contains a point //q//.
-  * //Example://\\ To find the face whose outer cone contains a given point, type \\ <code> >  print containing_outer_cone(cube(3), new Vector([1,2,2,2]));
- {7}
-</code>
-{{anchor:violations(Cone P, Vector q):}} **''violations(Cone P, Vector q)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Algebraic Types/Vector ''q'' : \\
-  * //Returns:// /common/property_types/Set Types/Set
-  *      Check which relations, if any, are violated by a point.
-  * //Example://\\ This calculates and prints the violated equations defining a square with the origin as its center and side length 2 with respect to a certain point: \\ <code> >  $p = cube(2);
- $v = new Vector([1,2,2]);
- $S = violations($p,$v);
- print $S;
- {1 3}
-</code>
-{{anchor:containing_normal_cone(Cone P, Vector q):}} **''containing_normal_cone(Cone P, Vector q)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Algebraic Types/Vector ''q'' : \\
-  * //Returns:// /common/property_types/Set Types/Set
-  *      Return the vertices of the face of P whose normal cone contains a point //q//.
-  * //Example://\\ To find the face whose normal cone contains a given point, type \\ <code> >  $p = new Polytope(VERTICES=>[[1,-1,0],[1,0,-1],[1,0,1],[1,100,0]]);
- print containing_normal_cone($p, new Vector([1,1,2]));
- {2 3}
-</code>
-{{anchor:center_distance(Polytope p):}} **''center_distance(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\
-  * //Returns:// /common/property_types/Basic Types/Float
-  *      Compute the mean or median distance of the [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] to the [[/polytope/objects/Polytope/properties/Geometry/VERTEX_BARYCENTER]].
-----
-==== Optimization ====
- These functions provide tools from linear, integer and dicrete optimization. In particular, linear programs are defined here.
-{{anchor:write_symmetrized_simplexity_ilp(Polytope P, Int> isotypic_components, String outfile_name):}} **''write_symmetrized_simplexity_ilp(Polytope P, Int> isotypic_components, String outfile_name)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Set Types/Set</common/property_types/Basic Types/Int> ''isotypic_components'' : the set of indices of isotypic components to project to; default [0]
-\\ /common/property_types/Basic Types/String ''outfile_name'' : . Setting this to '-' (as is the default) prints the LP to stdout.
-\\
-  *      construct a linear program whose optimal value is a lower bound for\\     the minimal number of simplices in a triangulation of P.\\     The symmetry group of P is taken into account, in that the\\     variables in the linear program are projections of the indicator\\     variables of the maximal interior simplices to a given direct sum of\\     isotypic components of the symmetry group of P acting on these simplices.
-  * //Example://\\  For the 3-cube, the symmetrized LP for isotypic component 0 reads as follows: \\ <code> >  write_symmetrized_simplexity_ilp(cube(3,group=>1));
- MINIMIZE
-   obj: +1 x1 +1 x2 +1 x3 +1 x4
- Subject To
-   ie0: +1 x1 >= 0
-   ie1: +1 x2 >= 0
-   ie2: +1 x3 >= 0
-   ie3: +1 x4 >= 0
-   eq0: +8 x1 +8 x2 +8 x3 +16 x4 = 48
-   eq1: -6 x1 +6 x3 +24 x4 = 0
- BOUNDS
-   x1 free
-   x2 free
-   x3 free
-   x4 free
- GENERAL
-   x1
-   x2
-   x3
-   x4
- END
-</code>\\  The interpretation is as follows: The variables x1,...,x4 correspond to the representatives of interior simplices: \\ <code> >  print cube(3,group=>1)->GROUP->REPRESENTATIVE_MAX_INTERIOR_SIMPLICES;
- {0 1 2 4}
- {0 1 2 5}
- {0 1 2 7}
- {0 3 5 6}
-</code>\\  The solution (x1,x2,x3,x4) = (4,0,0,1) of the LP says that in a minimal triangulation of the 3-cube,  there are 4 simplices in the same symmetry class as {0,1,2,4}, and one in the class of {0,3,5,6}. \\
-{{anchor:core_point_algo_Rote(Polytope p, Rational optLPvalue):}} **''core_point_algo_Rote(Polytope p, Rational optLPvalue)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\ /common/property_types/Basic Types/Rational ''optLPvalue'' : optimal value of LP approximation
-\\
-  * //Returns:// /common/property_types/Basic Types/List
-  *      Version of core_point_algo with improved running time\\     (according to a suggestion by G. Rote).\\     The core_point_algo is an algorithm to solve highly symmetric integer linear programs (ILP).\\     It is required that the group of the ILP induces the alternating or symmetric group\\     on the set of coordinate directions.\\     The linear objective function is the vector (0,1,1,..,1).
-{{anchor:find_transitive_lp_sol(Matrix Inequalities):}} **''find_transitive_lp_sol(Matrix Inequalities)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''Inequalities'' : the inequalities describing the feasible region
-\\
-  * //Returns:// /common/property_types/Basic Types/List
-  *      Algorithm to solve symmetric linear programs (LP) of the form\\     max c<sup>t</sup>x , c=(0,1,1,..,1)\\     subject to the inequality system given by //Inequalities//.\\     It is required that the symmetry group of the LP acts transitively\\     on the coordinate directions.
-  * //Example://\\ Consider the LP described by the facets of the 3-cube: \\ <code> >  @sol=find_transitive_lp_sol(cube(3)->FACETS);
- print $_, "\n" for @sol;
-1 1 1
- true
- true
-</code>\\  The optimal solution is [1,1,1,1], its value under c is 3, and the LP is feasible and bounded in direction of c. \\
-{{anchor:rand_aof(Polytope P, Int start):}} **''rand_aof(Polytope P, Int start)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : a __simple__ polytope
-\\ /common/property_types/Basic Types/Int ''start'' : the index of the starting vertex; default value: random
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Rational>
-  *      Produce a random abstract objective function on a given __simple__ polytope //P//.\\     It is assumed that the boundary complex of the dual polytope is extendibly shellable.\\     If, during the computation, it turns out that a certain partial shelling cannot be extended,\\     then this is given instead of an abstract objective function.\\     It is possible (but not required) to specify the index of the starting vertex //start//.
-{{anchor:separating_hyperplane:}} **''separating_hyperplane''**
-{{anchor:totally_dual_integral(Matrix inequalities):}} **''totally_dual_integral(Matrix inequalities)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''inequalities'' : \\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Checks weather a given system of inequalities is totally dual integral or not.\\     The inequalities should describe a full dimensional polyhedron
-  * //Example://\\  \\ <code> >  print totally_dual_integral(cube(2)->FACETS);
- true
-</code>
-{{anchor:write_foldable_max_signature_ilp(Polytope P, String outfile_name):}} **''write_foldable_max_signature_ilp(Polytope P, String outfile_name)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/String ''outfile_name'' : \\
-  *      construct a linear program whose optimal value is an upper bound for the algebraic signature of \\     a triangulation of P. This is the absolute value of the difference of normalized volumes of black\\     minus white simplices (counting only those with odd normalized volume) in a triangulation of P\\     whose dual graph is bipartite.\\     If P has a GROUP, it will be used to construct the linear program.
-  * //Example://\\  For the 0/1 2-cube without a GROUP, the foldable max signature lp is computed as follows: \\ <code> >  write_foldable_max_signature_ilp(cube(2,0));
- MINIMIZE
-   obj: +1 x1 -1 x2 +1 x3 -1 x4 +1 x5 -1 x6 +1 x7 -1 x8
- Subject To
-   ie0: +1 x1 >= 0
-   ie1: +1 x2 >= 0
-   ie2: +1 x3 >= 0
-   ie3: +1 x4 >= 0
-   ie4: +1 x5 >= 0
-   ie5: +1 x6 >= 0
-   ie6: +1 x7 >= 0
-   ie7: +1 x8 >= 0
-   ie8: -1 x1 -1 x2 >= -1
-   ie9: -1 x3 -1 x4 >= -1
-   ie10: -1 x5 -1 x6 >= -1
-   ie11: -1 x7 -1 x8 >= -1
-   eq0: -1 x4 +1 x5 = 0
-   eq1: +1 x3 -1 x6 = 0
-   eq2: -1 x2 +1 x7 = 0
-   eq3: +1 x1 -1 x8 = 0
-   eq4: +1 x1 +1 x2 +1 x3 +1 x4 +1 x5 +1 x6 +1 x7 +1 x8 = 2
- BOUNDS
-   x1 free
-   x2 free
-   x3 free
-   x4 free
-   x5 free
-   x6 free
-   x7 free
-   x8 free
- GENERAL
-   x1
-   x2
-   x3
-   x4
-   x5
-   x6
-   x7
-   x8
- END
-</code>\\  There are eight variables, one for each possible black or white maximal interior simplex. The optimal value of this LP is zero, because any triangulation has exactly one black and one white simplex of odd normalized volume. Notice that the objective function becomes empty for cube(2), because in the +1/-1 cube, each simplex has even volume. \\
-  * //Example://\\  For the 0/1 3-cube, we use a GROUP property: \\ <code> >  write_foldable_max_signature_ilp(cube(3,0,group=>1));
- MINIMIZE
-   obj: +1 x1 -1 x2 +1 x3 -1 x4 +1 x5 -1 x6
- Subject To
-   ie0: +1 x1 >= 0
-   ie1: +1 x2 >= 0
-   ie2: +1 x3 >= 0
-   ie3: +1 x4 >= 0
-   ie4: +1 x5 >= 0
-   ie5: +1 x6 >= 0
-   ie6: +1 x7 >= 0
-   ie7: +1 x8 >= 0
-   ie8: -1 x1 -1 x2 >= -8
-   ie9: -1 x3 -1 x4 >= -24
-   ie10: -1 x5 -1 x6 >= -24
-   ie11: -1 x7 -1 x8 >= -2
-   eq0: +2 x3 -2 x4 +2 x5 -2 x6 = 0
-   eq1: -2 x3 +2 x4 -2 x5 +2 x6 = 0
-   eq2: -6 x2 +6 x5 +24 x7 = 0
-   eq3: -6 x1 +6 x6 +24 x8 = 0
-   eq4: +1 x1 +1 x2 +1 x3 +1 x4 +1 x5 +1 x6 +2 x7 +2 x8 = 6
- BOUNDS
-   x1 free
-   x2 free
-   x3 free
-   x4 free
-   x5 free
-   x6 free
-   x7 free
-   x8 free
- GENERAL
-   x1
-   x2
-   x3
-   x4
-   x5
-   x6
-   x7
-   x8
- END
-</code>\\  There are again 8 variables, but now they correspond to the black and white representatives of the four symmetry classes of maximal interior simplices. The optimal value of this linear program is 4, because the most imbalanced triangulation is the one with 5 simplices, in which the volume of the big interior simplex is even and doesn't get counted in the objective function. \\
-{{anchor:poly2lp(Polytope P, LinearProgram LP, Bool maximize, String file):}} **''poly2lp(Polytope P, LinearProgram LP, Bool maximize, String file)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /polytope/objects/Optimization/LinearProgram ''LP'' : default value: //P//->LP
-\\ /common/property_types/Basic Types/Bool ''maximize'' : produces a maximization problem; default value: 0 (minimize)
-\\ /common/property_types/Basic Types/String ''file'' : default value: standard output
-\\
-  *      Convert a polymake description of a polyhedron to LP format (as used by CPLEX and\\     other linear problem solvers) and write it to standard output or to a //file//.\\     If //LP// comes with an attachment 'INTEGER_VARIABLES' (of type Array<Bool>),\\     the output will contain an additional section 'GENERAL',\\     allowing for IP computations in CPLEX.\\     If the polytope is not FEASIBLE, the function will throw a runtime error.
-{{anchor:write_simplexity_ilp(Polytope P):}} **''write_simplexity_ilp(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  *      construct a linear program whose optimal value is a lower bound for the minimal number of simplices\\     in a triangulation of P.
-  * //Example://\\  To print the linear program for the 2-dimensional cube, write \\ <code> >  write_simplexity_ilp(cube(2));
- MINIMIZE
-   obj: +1 x1 +1 x2 +1 x3 +1 x4
- Subject To
-   ie0: +1 x1 >= 0
-   ie1: +1 x2 >= 0
-   ie2: +1 x3 >= 0
-   ie3: +1 x4 >= 0
-   eq0: +4 x1 +4 x2 +4 x3 +4 x4 = 8
-   eq1: -1 x2 +1 x3 = 0
-   eq2: -1 x1 +1 x4 = 0
- BOUNDS
-   x1 free
-   x2 free
-   x3 free
-   x4 free
- GENERAL
-   x1
-   x2
-   x3
-   x4
- END
-</code>
-{{anchor:vertex_colors(Polytope P, LinearProgram LP):}} **''vertex_colors(Polytope P, LinearProgram LP)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /polytope/objects/Optimization/LinearProgram ''LP'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Visualization/RGB>
-  *      Calculate RGB-color-values for each vertex depending on a linear or abstract objective function.\\     Maximal and minimal affine vertices are colored as specified.  Far vertices (= rays) orthogonal\\     to the linear function normal vector are white.  The colors for other affine vertices\\     are linearly interpolated in the HSV color model.\\    \\     If the objective function is linear and the corresponding LP problem is unbounded, then\\     the affine vertices that would become optimal after the removal of the rays are painted pale.
-  * //Example://\\ This calculates a vertex coloring with respect to a linear program. For a better visualization, we also set the vertex thickness to 2. \\ <code> >  $p = cube(3);
- $p->LP(LINEAR_OBJECTIVE=>[0,1,2,3]);
- $v = vertex_colors($p,$p->LP);
- $p->VISUAL(VertexColor=>$v,VertexThickness=>2);
-</code>
-{{anchor:ball_lifting_lp(GeometricSimplicialComplex c, Int facet_index, Rational conv_eps):}} **''ball_lifting_lp(GeometricSimplicialComplex c, Int facet_index, Rational conv_eps)''**
-  * //Parameters:
-/topaz/objects/GeometricSimplicialComplex ''c'' : \\ /common/property_types/Basic Types/Int ''facet_index'' : index of the facet to be lifted
-\\ /common/property_types/Basic Types/Rational ''conv_eps'' : some epsilon > 0
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Computes the inequalities and the linear objective for an LP to lift a simplicial //d//-ball embedded\\     starshaped in R<sup>d</sup>.
-{{anchor:random_edge_epl(Directed> G):}} **''random_edge_epl(Directed> G)''**
-  * //Parameters:
-/graph/objects/Combinatorics/Graph</common/property_types/Artificial/Directed> ''G'' : a directed graph
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Rational>
-  *      Computes a vector containing the expected path length to the maximum\\     for each vertex of a directed graph //G//.\\     The random edge pivot rule is applied.
-{{anchor:inner_point(Matrix points):}} **''inner_point(Matrix points)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/Vector
-  *      Compute a true inner point of a convex hull of the given set of //points//.
-  * //Example://\\ To print an inner point of the square, do this: \\ <code> >  print inner_point(cube(2)->VERTICES);
--1/3 -1/3
-</code>
-{{anchor:core_point_algo(Polytope p, Rational optLPvalue):}} **''core_point_algo(Polytope p, Rational optLPvalue)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\ /common/property_types/Basic Types/Rational ''optLPvalue'' : optimal value of LP approximation
-\\
-  * //Returns:// /common/property_types/Basic Types/List
-  *      Algorithm to solve highly symmetric integer linear programs (ILP).\\     It is required that the group of the ILP induces the alternating or symmetric group\\     on the set of coordinate directions.\\     The linear objective function is the vector (0,1,1,..,1).
-{{anchor:lp2poly<Scalar>:}} **''lp2poly<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : coordinate type of the resulting polytope; default is [[/common/property_types/Basic Types/Rational]].
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Optimization/lp2poly/tparams/Scalar>
-  *      Read a linear programming problem given in LP-Format (as used by cplex & Co.)\\     and convert it to a [[]] object.\\    \\     **WARNING** The property FEASIBLE is **NOT** computed upon creation.\\     This is done to avoid possibly long computation times before the object becomes available to the caller.\\     This is **NOT** in keeping with standard practice in polymake, but after, all, these are linear programs\\     and not polytopes.
-{{anchor:write_simplexity_ilp_with_angles(Polytope P, String outfile_name):}} **''write_simplexity_ilp_with_angles(Polytope P, String outfile_name)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/String ''outfile_name'' : \\
-  *      construct a linear program whose optimal value is a lower bound for the minimal number of simplices\\     in a triangulation of P, and that takes into account the angle constraint around codimension 2 faces.\\     The first set of variables correspond to possible maximal internal simplices, the second set to the\\     simplices of codimension 2. See the source file polytope/src/symmetrized_codim_2_angle_sums.cc for details.
-  * //Example://\\  To print the linear program for the 2-dimensional cube, write \\ <code> >  write_simplexity_ilp_with_angles(cube(2));
- MINIMIZE
-   obj: +1 x1 +1 x2 +1 x3 +1 x4
- Subject To
-   ie0: +1 x1 >= 0
-   ie1: +1 x2 >= 0
-   ie2: +1 x3 >= 0
-   ie3: +1 x4 >= 0
-   ie4: +1 x5 >= 0
-   ie5: +1 x6 >= 0
-   ie6: +1 x7 >= 0
-   ie7: +1 x8 >= 0
-   eq0: -1 x2 +1 x3 = 0
-   eq1: -1 x1 +1 x4 = 0
-   eq2: +0.5 x1 +0.25 x2 +0.2500000000000001 x3 -0.5 x5 = 0
-   eq3: +0.25 x1 +0.5 x3 +0.2500000000000001 x4 -0.5 x6 = 0
-   eq4: +0.25 x1 +0.5 x2 +0.2500000000000001 x4 -0.5 x7 = 0
-   eq5: +0.25 x2 +0.2500000000000001 x3 +0.5 x4 -0.5 x8 = 0
-   eq6: +1 x5 = 1
-   eq7: +1 x6 = 1
-   eq8: +1 x7 = 1
-   eq9: +1 x8 = 1
-   eq10: +4 x1 +4 x2 +4 x3 +4 x4 = 8
- BOUNDS
-   x1 free
-   x2 free
-   x3 free
-   x4 free
-   x5 free
-   x6 free
-   x7 free
-   x8 free
- GENERAL
-   x1
-   x2
-   x3
-   x4
-   x5
-   x6
-   x7
-   x8
- END
-</code>
-{{anchor:print_constraints(Scalar> C):}} **''print_constraints(Scalar> C)''**
-  * //Parameters:
-/polytope/objects/Cone</polytope/functions/Optimization/print_constraints/tparams/Scalar> ''C'' : the given polytope or cone
-\\
-  *      Write the [[/polytope/objects/Cone/properties/Geometry/FACETS]] / [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]] and the [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]] / [[/polytope/objects/Cone/properties/Input property/EQUATIONS]] (if present)\\     of a polytope //P// or cone //C// in a readable way.\\     [[/polytope/objects/Cone/properties/Visualization/COORDINATE_LABELS]] are adopted if present.
-  * //Example://\\ The following prints the facet inequalities of the square, changing the labels. \\ <code> >  print_constraints(cube(2),ineq_labels=>['zero','one','two','three']);
- Facets:
- zero: x1 >= -1
- one: -x1 >= -1
- two: x2 >= -1
- three: -x2 >= -1
-</code>
-{{anchor:porta2poly(String file):}} **''porta2poly(String file)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''file'' : filename of a porta file (.ieq or .poi)
-\\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Basic Types/Rational>
-  *       Read an .ieq or .poi file (porta input) or .poi.ieq or .ieq.poi (porta output)\\      and convert it to a [[]] object
-----
-==== Other ====
- Special purpose functions.
-{{anchor:lawrence_matrix(Matrix M):}} **''lawrence_matrix(Matrix M)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''M'' : Create the Lawrence matrix Lambda(M) corresponding to M.
- If //M// has //n// rows and //d// columns, then Lambda(M) equals
- ( //M//       //I_n// )
- ( //0_{n,d}// //I_n// ).
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *
-{{anchor:wronski_system(Int> M, Int> lambda, Rational>> coeff_array, Rational s):}} **''wronski_system(Int> M, Int> lambda, Rational>> coeff_array, Rational s)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Int> ''M'' : points (in homogeneous coordinates); affinely span the space
-\\ /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Int> ''lambda'' : height function on lattice points
-\\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Array</common/property_types/Basic Types/Rational>> ''coeff_array'' : coefficients
-\\ /common/property_types/Basic Types/Rational ''s'' : additional Parameter in the polynomial
-\\
-  *      Returns a Wronski system of a [[/topaz/objects/SimplicialComplex/properties/Combinatorics/FOLDABLE]] triangulation of a lattice polytope
-{{anchor:wronski_center_ideal(Int> L, Int> lambda):}} **''wronski_center_ideal(Int> L, Int> lambda)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Int> ''L'' : lattice points
-\\ /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Int> ''lambda'' : height function on lattice points
-\\
-  *      Returns a system of polynomials which is\\     necessary to check if degeneration avoids center of projection:\\     compute eliminant e(s); this must not have a zero in (0,1)
-{{anchor:m_sequence(Int> h):}} **''m_sequence(Int> h)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Int> ''h'' : \\
-  * //Returns:// /common/property_types/Basic Types/Bool
-  *      Test if the given vector is an M-sequence.
-  * //Example://\\ The h-vector of a simplicial or simple polytope is an M-sequence. \\ <code> >  print m_sequence(cyclic(7,23)->H_VECTOR);
- true
-</code>
-{{anchor:wronski_polynomial(Int> M, Int> lambda, Rational> coeff, Rational s):}} **''wronski_polynomial(Int> M, Int> lambda, Rational> coeff, Rational s)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Int> ''M'' : points (in homogeneous coordinates); affinely span the space
-\\ /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Int> ''lambda'' : height function on lattice points
-\\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Rational> ''coeff'' : coefficients
-\\ /common/property_types/Basic Types/Rational ''s'' : additional Parameter in the polynomial
-\\
-  *      Returns a Wronski polynomial of a [[/topaz/objects/SimplicialComplex/properties/Combinatorics/FOLDABLE]] triangulation of a lattice polytope
-{{anchor:edge_orientable(Polytope P):}} **''edge_orientable(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the given 2-cubical polytope
-\\
-  *      Checks whether a 2-cubical polytope //P// is __edge-orientable__ \\     (in the sense of Hetyei), that means that there exits an orientation \\     of the edges such that for each 2-face the opposite edges point \\     in the same direction.\\     It produces the certificates [[/polytope/objects/Polytope/properties/Combinatorics/EDGE_ORIENTATION]] if the polytope is\\     edge-orientable, or [[/polytope/objects/Polytope/properties/Combinatorics/MOEBIUS_STRIP_EDGES]] otherwise.\\     In the latter case, \\     the output can be checked with the client [[/polytope/functions/Consistency check/validate_moebius_strip]].
-{{anchor:matroid_indices_of_hypersimplex_vertices:}} **''matroid_indices_of_hypersimplex_vertices''**
-  * //Returns:// /common/property_types/Set Types/Set</common/property_types/Basic Types/Int>
-  *      For a given matroid return the bases as a\\     subset of the vertices of the hypersimplex
-{{anchor:face_pair(Cone P, Set S):}} **''face_pair(Cone P, Set S)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Set Types/Set ''S'' : \\
-  * //Returns:// /common/property_types/Basic Types/Pair</common/property_types/Set Types/Set,/common/property_types/Set Types/Set>
-  *      For a given set S of rays compute the smallest face F of a cone P containing them all; see also //face//.
-  * //Example://\\ computes the dimension of the face of the 3-cube which is spanned by the vertices 0 and 1 \\ <code> >  $c=cube(3);
- print rank($c->VERTICES->minor(face_pair($c,[0,1])->first(),All))-1;
-</code>
-----
-==== Producing a cone ====
- Various constructions of cones.
-{{anchor:inner_cone(Cone p, Int> F):}} **''inner_cone(Cone p, Int> F)''**
-  * //Parameters:
-/polytope/objects/Cone ''p'' : \\ /common/property_types/Set Types/Set</common/property_types/Basic Types/Int> ''F'' : (or Int v) vertex indices which are not contained in the far face
-\\
-  * //Returns:// /polytope/objects/Cone
-  *      Computes the inner cone of //p// at a face //F// (or a vertex //v//).
-  * //Example://\\ To compute the inner cone at a vertex of the 3-cube, do this: \\ <code> >  $c = inner_cone(cube(3), 1);
- print $c->RAYS;
- -1 0 0
-1 0
-0 1
-</code>
-  * //Example://\\ To compute the inner cone along an edge of the 3-cube, and make it point outside the polytope, do this: \\ <code> >  print inner_cone(cube(3), [0,1], outer=>1)->RAYS;
-0 -1
--1 0
-</code>
-  * //Example://\\ If you want to attach the cone to the polytope, specify the corresponding option: \\ <code> >  print normal_cone(cube(3), [0,1], attach=>1)->RAYS;
--1 -1 -1
-1 -1 -1
-0 1 0
-0 0 1
-</code>
-{{anchor:recession_cone(Scalar> P):}} **''recession_cone(Scalar> P)''**
-  * //Parameters:
-/polytope/objects/Polytope</polytope/functions/Producing a cone/recession_cone/tparams/Scalar> ''P'' : polytope
-\\
-  * //Returns:// /polytope/objects/Cone</polytope/functions/Producing a cone/recession_cone/tparams/Scalar>
-  *      retuns the recession cone (tail cone, characteristic cone) of a polytope
-{{anchor:subcone(Cone C):}} **''subcone(Cone C)''**
-  * //Parameters:
-/polytope/objects/Cone ''C'' : the input cone
-\\
-  * //Returns:// /polytope/objects/Cone
-  *      Make a subcone from a cone.
-{{anchor:normal_cone:}} **''normal_cone''**
-----
-==== Producing a point configuration ====
- Constructing a point configuration, either from scratch or from existing objects.
-{{anchor:minkowski_sum:}} **''minkowski_sum''**
-----
-==== Producing a polytope from graphs ====
- Polytope constructions which take graphs as input.
-{{anchor:flow_polytope:}} **''flow_polytope''**
-{{anchor:tutte_lifting(Graph G):}} **''tutte_lifting(Graph G)''**
-  * //Parameters:
-/graph/objects/Combinatorics/Graph ''G'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Let //G// be a 3-connected planar graph. If the corresponding polytope\\     contains a triangular facet (ie. the graph contains a non-\\     separating cycle of length 3), the client produces a realization\\     in R<sup>3</sup>.
-{{anchor:fractional_matching_polytope(Graph G):}} **''fractional_matching_polytope(Graph G)''**
-  * //Parameters:
-/graph/objects/Combinatorics/Graph ''G'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Matching polytope of an undirected graph.
-{{anchor:fractional_cut_polytope(Graph G):}} **''fractional_cut_polytope(Graph G)''**
-  * //Parameters:
-/graph/objects/Combinatorics/Graph ''G'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Cut polytope of an undirected graph.
-{{anchor:weighted_digraph_polyhedron(Matrix encoding):}} **''weighted_digraph_polyhedron(Matrix encoding)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''encoding'' : weighted digraph
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Weighted digraph polyhedron of a directed graph with a weight function.\\     The graph and the weight function are combined into a matrix.
-----
-==== Producing a polytope from other objects ====
- Polytope constructions which take other big objects as input.
-{{anchor:billera_lee(Integer> H):}} **''billera_lee(Integer> H)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Integer> ''H'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces a simplicial polytope whose H-vector is the given input vector.\\     The G-vector coming from the given vector must be an M-sequence.\\     This is an implementation of the algorithm described in the paper\\     "A Proof of the Sufficiency of McMullen’s Conditions of Simplicial Convex Polytopes"\\     by Louis Billera and Carl Lee, DOI: 10.1016/0097-3165(81)90058-3
-  * //Example://\\  \\ <code> >  $p = billera_lee([1,5,15,15,5,1]);
- print $p->H_VECTOR;
-5 15 15 5 1
-</code>
-----
-==== Producing a polytope from polytopes ====
- An important way of constructing polytopes is to modify an
- already existing polytope.
- Actually, these functions don't alter the input polytope
- (it is forbidden in polymake), but create a new polytope object.
- Many functions can at your choice either calculate the vertex or facet coordinates,
- or constrain themselves on the purely combinatorial description of the
- resulting polytope.
-{{anchor:blending(Polytope P1, Int v1, Polytope P2, Int v2):}} **''blending(Polytope P1, Int v1, Polytope P2, Int v2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /common/property_types/Basic Types/Int ''v1'' : the index of the first vertex
-\\ /polytope/objects/Polytope ''P2'' : \\ /common/property_types/Basic Types/Int ''v2'' : the index of the second vertex
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Compute the blending of two polyhedra at simple vertices.\\     This is a slightly less standard construction.\\     A vertex is __simple__ if its vertex figure is a simplex.\\    \\     Moving a vertex //v// of a bounded polytope to infinity yields an unbounded polyhedron\\     with all edges through //v// becoming mutually parallel rays.  Do this to both\\     input polytopes //P1// and //P2// at simple vertices //v1// and //v2//, respectively.\\     Up to an affine transformation one can assume that the orthogonal projections\\     of //P1// and //P2// in direction //v1// and //v2//, respectively, are mutually congruent.\\    \\     Any bijection b from the set of edges through //v1// to the edges through //v2//\\     uniquely defines a way of glueing the unbounded polyhedra to obtain a new bounded\\     polytope, the __blending__ with respect to b. The bijection is specified as a //permutation//\\     of indices 0 1 2 etc. The default permutation is the identity.\\    \\     The number of vertices of the blending is the sum of the numbers of vertices of the\\     input polytopes minus 2.  The number of facets is the sum of the numbers of facets\\     of the input polytopes minus the dimension.\\    \\     The resulting polytope is described only combinatorially.
-  * //Example://\\ The following gives the smallest [[/polytope/objects/Cone/methods/Combinatorics/EVEN]] 3-polytope which is not a zonotope. \\ <code> >  $c = cube(3); $bc = blending($c,0,$c,0);
- print $bc->EVEN
- true
-</code>\\  \\ <code> >  print $bc->F_VECTOR
-21 9
-</code>
-{{anchor:lawrence(Cone P):}} **''lawrence(Cone P)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : an input cone or polytope
-\\
-  * //Returns:// /polytope/objects/Cone
-  *      Create the Lawrence polytope Lambda(P) corresponding to P.\\     Lambda(P) has the property that\\     Gale(Lambda(P)) = Gale(P) union -Gale(P).
-{{anchor:mapping_polytope(Polytope P1, Polytope P2):}} **''mapping_polytope(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/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<sup>p</sup> to R<sup>q</sup>, that map //P1// into //P2//.\\    \\     The label of a new facet corresponding to v<sub>1</sub> and h<sub>1</sub> will have the form\\     "v<sub>1</sub>*h<sub>1</sub>".
-{{anchor:cells_from_subdivision(Scalar> P, Int> cells):}} **''cells_from_subdivision(Scalar> P, Int> cells)''**
-  * //Parameters:
-/polytope/objects/Polytope</polytope/functions/Producing a polytope from polytopes/cells_from_subdivision/tparams/Scalar> ''P'' : \\ /common/property_types/Set Types/Set</common/property_types/Basic Types/Int> ''cells'' : \\
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing a polytope from polytopes/cells_from_subdivision/tparams/Scalar>
-  *      Extract the given //cells// of the subdivision of a polyhedron and create a\\     new polyhedron that has as vertices the vertices of the cells.
-  * //Example://\\ First we create a nice subdivision for a small polytope: \\ <code> >  $p = new Polytope(VERTICES=>[[1,0,0],[1,0,1],[1,1,0],[1,1,1],[1,3/2,1/2]]);
- $p->POLYTOPAL_SUBDIVISION(MAXIMAL_CELLS=>[[0,1,3],[1,2,3],[2,3,4]]);
-</code>\\  Then we create the polytope that has as vertices the vertices from cell 1 and 2, while keeping their labels. \\ <code> >  $c = cells_from_subdivision($p,[1,2]);
- print $c->VERTICES;
-0 1
-1 0
-1 1
-3/2 1/2
-</code>\\  \\ <code> >  print $c->VERTEX_LABELS;
-2 3 4
-</code>
-{{anchor:free_sum(Polytope P1, Polytope P2):}} **''free_sum(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct a new polyhedron as the free sum of two given bounded ones.
-  * //Example://\\  \\ <code> >  $p = free_sum(cube(2),cube(2));
- print $p->VERTICES;
--1 -1 0 0
-1 -1 0 0
--1 1 0 0
-1 1 0 0
-0 0 -1 -1
-0 0 1 -1
-0 0 -1 1
-0 0 1 1
-</code>
-{{anchor:minkowski_sum:}} **''minkowski_sum''**
-{{anchor:wedge(Polytope P, Int facet, Rational z, Rational z_prime):}} **''wedge(Polytope P, Int facet, Rational z, Rational z_prime)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : , must be bounded
-\\ /common/property_types/Basic Types/Int ''facet'' : the `cutting edge'.
-\\ /common/property_types/Basic Types/Rational ''z'' : default value is 0.
-\\ /common/property_types/Basic Types/Rational ''z_prime'' : default value is -//z//, or 1 if //z//==0.
-\\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ This produces the wedge from a square (over the facet 0), which yields a prism over a triangle: \\ <code> >  $p = wedge(cube(2),0);
- print $p->VERTICES;
--1 -1 0
-1 -1 0
--1 1 0
-1 1 0
-1 -1 2
-1 1 2
-</code>
-{{anchor:dual_linear_program(Polytope P, Bool maximize):}} **''dual_linear_program(Polytope P, Bool maximize)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : = {x | Ax >= b, Bx = d}
-\\ /common/property_types/Basic Types/Bool ''maximize'' : tells if the primal lp is a maximization problem. Default value is 0 (= minimize)
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces the dual linear program for a given linear program of the form min {cx | Ax >= b, Bx = d}.\\     Here (A,b) are given by the FACETS (or the INEQAULITIES), and (B,d) are given by the AFFINE_HULL\\     (or by the EQUATIONS) of the polytope P, while the objective function c comes from an LP subobject.
-{{anchor:free_sum_decomposition(Polytope P):}} **''free_sum_decomposition(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</polytope/objects/Polytope>
-  *      Decompose a given polytope into the free sum of smaller ones
-{{anchor:truncation(Polytope P, Int> trunc_vertices):}} **''truncation(Polytope P, Int> trunc_vertices)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Set Types/Set</common/property_types/Basic Types/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.
-\\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ To truncate the second vertex of the square at 1/4, try this: \\ <code> >  $p = truncation(cube(2),2,cutoff=>1/4);
- print $p->VERTICES;
--1 -1
-1 -1
-1 1
--1 1/2
--1/2 1
-</code>
-{{anchor:minkowski_sum_fukuda(Polytope> summands):}} **''minkowski_sum_fukuda(Polytope> summands)''**
-  * //Parameters:
-/common/property_types/Basic Types/Array</polytope/objects/Polytope> ''summands'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Computes the ([[/polytope/objects/Polytope/properties/Geometry/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.
-  * //Example://\\  \\ <code> >  $p = minkowski_sum_fukuda([cube(2),simplex(2),cross(2)]);
- print $p->VERTICES;
-3 -1
-3 1
--1 -2
-1 3
--1 3
-2 -2
--2 2
--2 -1
-</code>
-{{anchor:prism(Polytope P, Scalar z1, Scalar z2):}} **''prism(Polytope P, Scalar z1, Scalar z2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the input polytope
-\\ /polytope/functions/Producing a polytope from polytopes/prism/tparams/Scalar ''z1'' : the left endpoint of the interval; default value: -1
-\\ /polytope/functions/Producing a polytope from polytopes/prism/tparams/Scalar ''z2'' : the right endpoint of the interval; default value: -//z1//
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Make a prism over a pointed polyhedron.\\     The prism is the product of the input polytope //P// and the interval [//z1//, //z2//].
-  * //Example://\\ The following saves the prism over the square and the interval [-2,2] to the variable $p, and then prints a nice representation of its vertices. \\ <code> >  $p = prism(cube(2),-2);
- print rows_labeled($p->VERTICES,$p->VERTEX_LABELS);
-:1 -1 -1 -2
-:1 1 -1 -2
-:1 -1 1 -2
-:1 1 1 -2
-':1 -1 -1 2
-':1 1 -1 2
-':1 -1 1 2
-':1 1 1 2
-</code>
-{{anchor:pyramid(Polytope P, Scalar z):}} **''pyramid(Polytope P, Scalar z)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /polytope/functions/Producing a polytope from polytopes/pyramid/tparams/Scalar ''z'' : is the distance between the vertex barycenter and //v//,
-   default value is 1.
-\\
-  * //Returns:// /polytope/objects/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//.
-  * //Example://\\ The following saves the pyramid of height 2 over the square to the variable $p. The vertices are relabeled. \\ <code> >  $p = pyramid(cube(2),2);
-</code>\\  To print the vertices and vertex labels of the newly generated pyramid, do this: \\ <code> >  print $p->VERTICES;
--1 -1 0
-1 -1 0
--1 1 0
-1 1 0
-0 0 2
-</code>\\  \\ <code> >  print $p->VERTEX_LABELS;
-1 2 3 Apex
-</code>
-{{anchor:gc_closure(Polytope P):}} **''gc_closure(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces the gomory-chvatal closure of a full dimensional polyhedron
-{{anchor:mixed_integer_hull(Polytope P, Int> int_coords):}} **''mixed_integer_hull(Polytope P, Int> int_coords)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Int> ''int_coords'' : the coordinates to be integral;
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces the mixed integer hull of a polyhedron
-{{anchor:project_full(Cone P):}} **''project_full(Cone P)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\
-  * //Returns:// /polytope/objects/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.
-{{anchor:cayley_polytope(Polytope> P_Array):}} **''cayley_polytope(Polytope> P_Array)''**
-  * //Parameters:
-/common/property_types/Basic Types/Array</polytope/objects/Polytope> ''P_Array'' : an array containing the lattice polytopes P<sub>1</sub>,...,P<sub>k</sub>
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct the cayley polytope of a set of pointed lattice polytopes contained in //P_Array//\\     which is the convex hull of P<sub>1</sub>&times;e<sub>1</sub>, ..., P<sub>k</sub>&times;e<sub>k</sub>\\     where e<sub>1</sub>, ...,e<sub>k</sub> are the standard unit vectors in R<sup>k</sup>.\\     In this representation the last k coordinates always add up to 1.\\     The option //proj// projects onto the complement of the last coordinate.
-{{anchor:cayley_embedding:}} **''cayley_embedding''**
-{{anchor:product(Polytope P1, Polytope P2):}} **''product(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct a new polytope as the product of two given polytopes //P1// and //P2//.\\     As little additional properties of the input polytopes as possible are computed.\\     You can control this behaviour using the option flags.
-  * //Example://\\ The following builds the product of a square and an interval, without computing vertices of neither the input nor the output polytopes. \\ <code> >  $p = product(cube(2),cube(1), no_vertices=>1);
-</code>
-{{anchor:facet_to_infinity(Polytope P, Int i):}} **''facet_to_infinity(Polytope P, Int i)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Int ''i'' : the facet index
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Make an affine transformation such that the i-th facet is transformed to infinity
-  * //Example://\\ This generates the polytope that is the positive quadrant in 2-space: \\ <code> >  $q = new Polytope(VERTICES=>[[1,-1,-1],[1,0,1],[1,1,0]]);
- $pf = facet_to_infinity($q,2);
- print $pf->VERTICES;
--1 -1
-0 1
-0 1
-</code>
-{{anchor:vertex_figure(Polytope p, Int n):}} **''vertex_figure(Polytope p, Int n)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\ /common/property_types/Basic Types/Int ''n'' : number of the chosen vertex
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct the vertex figure of the vertex //n// of a polyhedron.\\     The vertex figure is dual to a facet of the dual polytope.
-  * //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. \\ <code> >  $p = vertex_figure(cube(3),5);
- print $p->VERTICES;
-1 -1 0
-0 -1 1
-1 0 1
-</code>
-{{anchor:stellar_all_faces(Polytope P, Int d):}} **''stellar_all_faces(Polytope P, Int d)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : , must be bounded
-\\ /common/property_types/Basic Types/Int ''d'' : the lowest dimension of the faces to be divided;
-   negative values: treated as the co-dimension; default value: 1.
-\\
-  * //Returns:// /polytope/objects/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.
-{{anchor:make_totally_dual_integral(Polytope P):}} **''make_totally_dual_integral(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces a polyhedron with an totally dual integral inequality formulation of a full dimensional polyhedron
-{{anchor:rand_inner_points(Polytope P, Int n):}} **''rand_inner_points(Polytope P, Int n)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the input polytope
-\\ /common/property_types/Basic Types/Int ''n'' : the number of random points
-\\
-  * //Returns:// /polytope/objects/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. [[/polytope/functions/Producing a polytope from polytopes/unirand]] for this.\\     The polytope must be [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]].
-{{anchor:pointed_part(Polytope P):}} **''pointed_part(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces the pointed part of a polyhedron
-  * //Example://\\  \\ <code> >  $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;
-0 0
-1 0
-0 1
-</code>
-{{anchor:spherize(Polytope P):}} **''spherize(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Project all vertices of a polyhedron //P// on the unit sphere.\\     //P// must be [[/polytope/objects/Polytope/properties/Geometry/CENTERED]] and [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]].
-  * //Example://\\ The following scales the 2-dimensional cross polytope by 23 and then projects it back onto the unit circle. \\ <code> >  $p = scale(cross(2),23);
- $s = spherize($p);
- print $s->VERTICES;
-1 0
--1 0
-0 1
-0 -1
-</code>
-{{anchor:intersection(Cone C ...):}} **''intersection(Cone C ...)''**
-  * //Parameters:
-/polytope/objects/Cone ''C ...'' : polyhedra and cones to be intersected
-\\
-  * //Returns:// /polytope/objects/Cone
-  *      Construct a new polyhedron or cone as the intersection of given polyhedra and/or cones.\\     Works only if all [[/polytope/objects/Cone/properties/Geometry/CONE_AMBIENT_DIM]] values are equal.\\     If the input contains both cones and polytopes, the output will be a polytope.
-  * //Example://\\  \\ <code> >  $p = intersection(cube(2), cross(2,3/2));
- print $p->VERTICES;
--1/2 1
--1 1/2
-1/2 1
-1 1/2
-1/2 -1
-1 -1/2
--1/2 -1
--1 -1/2
-</code>
-{{anchor:projection_preimage(Cone> P_Array):}} **''projection_preimage(Cone> P_Array)''**
-  * //Parameters:
-/common/property_types/Basic Types/Array</polytope/objects/Cone> ''P_Array'' : \\
-  * //Returns:// /polytope/objects/Cone
-  *      Construct a new polyhedron that projects to a given array of polyhedra.\\     If the n polyhedra are d_1, d_2, ..., d_n-dimensional and all have m vertices,\\     the resulting polyhedron is (d_1+...+d_n)-dimensional, has m vertices, and\\     the projection to the i-th d_i coordinates gives the i-th input polyhedron.
-  * //Example://\\  \\ <code> >  $p = projection_preimage(cube(2),cube(2));
- print $p->VERTICES;
--1 -1 -1 -1
-1 -1 1 -1
--1 1 -1 1
-1 1 1 1
-</code>
-{{anchor:join_polytopes(Polytope P1, Polytope P2):}} **''join_polytopes(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct a new polyhedron as the join of two given bounded ones.
-  * //Example://\\ To join two squares, use this: \\ <code> >  $p = join_polytopes(cube(2),cube(2));
- print $p->VERTICES;
--1 -1 -1 0 0
-1 -1 -1 0 0
--1 1 -1 0 0
-1 1 -1 0 0
-0 0 1 -1 -1
-0 0 1 1 -1
-0 0 1 -1 1
-0 0 1 1 1
-</code>
-{{anchor:tensor(Polytope P1, Polytope P2):}} **''tensor(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ The following creates the tensor product polytope of two squares and then prints its vertices. \\ <code> >  $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
-</code>
-{{anchor:wreath(Polytope P1, Polytope P2):}} **''wreath(Polytope P1, Polytope P2)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : \\ /polytope/objects/Polytope ''P2'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Construct a new polytope as the wreath product of two input polytopes //P1//, //P2//.\\     //P1// and //P2// have to be [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]].
-{{anchor:bipyramid(Polytope P, Scalar z, Scalar z_prime):}} **''bipyramid(Polytope P, Scalar z, Scalar z_prime)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /polytope/functions/Producing a polytope from polytopes/bipyramid/tparams/Scalar ''z'' : distance between the vertex barycenter and the first apex,
-  default value is 1.
-\\ /polytope/functions/Producing a polytope from polytopes/bipyramid/tparams/Scalar ''z_prime'' : distance between the vertex barycenter and the second apex,
-  default value is -//z//.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Make a bipyramid over a pointed polyhedron.\\     The bipyramid is the convex hull of the input polyhedron //P//\\     and two points (//v//, //z//), (//v//, //z_prime//)\\     on both sides of the affine span of //P//. For bounded polyhedra, the apex projections\\     //v// to the affine span of //P// coincide with the vertex barycenter of //P//.
-  * //Example://\\ Here's a way to construct the 3-dimensional cross polytope: \\ <code> >  $p = bipyramid(bipyramid(cube(1)));
- print equal_polyhedra($p,cross(3));
- true
-</code>
-{{anchor:facet(Cone P, Int facet):}} **''facet(Cone P, Int facet)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Basic Types/Int ''facet'' : \\
-  * //Returns:// /polytope/objects/Cone
-  *      Extract the given //facet// of a polyhedron and write it as a new polyhedron.
-  * //Example://\\ To create a cone from the vertices of the zeroth facet of the 3-cube, type this: \\ <code> >  $p = facet(cube(3),0);
-</code>
-{{anchor:unirand(Polytope P, Int n):}} **''unirand(Polytope P, Int n)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Int ''n'' : the number of random points
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a polytope with //n// random points that are\\     uniformly distributed within the given polytope //P//.\\     //P// must be bounded and full-dimensional.
-  * //Example://\\ 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: \\ <code> >  $p = unirand(cube(2),5);
-</code>
-  * //Example://\\ 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: \\ <code> >  $p = unirand(cube(2),5,boundary=>1);
-</code>
-{{anchor:edge_middle(Polytope P):}} **''edge_middle(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce the convex hull of all edge middle points of some polytope //P//.\\     The polytope must be [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]].
-{{anchor:face(Cone P, Set S):}} **''face(Cone P, Set S)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Set Types/Set ''S'' : \\
-  * //Returns:// /polytope/objects/Cone
-  *      For a given set S of rays compute the smallest face F of a cone P containing them all; see also //face_pair//.
-  * //Example://\\ To create a cone from the vertices of the zeroth facet of the 3-cube, type this: \\ <code> >  $p = face(cube(3),[0,1]);
-</code>
-{{anchor:lattice_bipyramid(Polytope P, Vector v, Vector v_prime, Rational z, Rational z_prime):}} **''lattice_bipyramid(Polytope P, Vector v, Vector v_prime, Rational z, Rational z_prime)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Algebraic Types/Vector ''v'' : basis point for the first apex
-\\ /common/property_types/Algebraic Types/Vector ''v_prime'' : basis for the second apex
-  If //v_prime// is omitted, //v// will be used for both apices.
-  If both //v// and //v_prime// are omitted, it tries to find two vertices which don't lie in a common facet.
-  If no such vertices can be found or //P// is a simplex, it uses an interior lattice point as
-  both //v// and //v_prime//.
-\\ /common/property_types/Basic Types/Rational ''z'' : height for the first apex, default value is 1
-\\ /common/property_types/Basic Types/Rational ''z_prime'' : height for the second apex, default value is -//z//
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Make a lattice bipyramid over a polyhedron.\\     The bipyramid is the convex hull of the input polyhedron //P//\\     and two points (//v//, //z//), (//v_prime//, //z_prime//)\\     on both sides of the affine span of //P//.
-  * //Example://\\ To create the bipyramid over a square and keep the vertex labels, do this: \\ <code> >  $p = lattice_bipyramid(cube(2),new Vector(1,0,0));
- print $p->VERTICES;
--1 -1 0
-1 -1 0
--1 1 0
-1 1 0
-0 0 1
-0 0 -1
-</code>\\  \\ <code> >  print $p->VERTEX_LABELS;
-1 2 3 Apex Apex'
-</code>
-{{anchor:free_sum_decomposition_indices(Polytope P):}} **''free_sum_decomposition_indices(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Set Types/Set>
-  *      Decompose a given polytope into the free sum of smaller ones, and return the vertex indices of the summands
-  * //Example://\\  \\ <code> >  $p = free_sum(cube(1),cube(1));
- print $p->VERTICES;
--1 0
-1 0
-0 -1
-0 1
-</code>\\  \\ <code> >  print free_sum_decomposition_indices($p);
- {0 1}
- {2 3}
-</code>
-{{anchor:cell_from_subdivision(Polytope P, Int cell):}} **''cell_from_subdivision(Polytope P, Int cell)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Int ''cell'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Extract the given //cell// of the subdivision of a polyhedron and write it as a new polyhedron.
-  * //Example://\\ First we create a nice subdivision for our favourite 2-polytope, the square: \\ <code> >  $p = cube(2);
- $p->POLYTOPAL_SUBDIVISION(MAXIMAL_CELLS=>[[0,1,3],[1,2,3]]);
-</code>\\  Then we extract the [1,2,3]-cell, copying the vertex labels. \\ <code> >  $c = cell_from_subdivision($p,1);
- print $c->VERTICES;
-1 -1
--1 1
-1 1
-</code>\\  \\ <code> >  print $c->VERTEX_LABELS;
-2 3
-</code>
-{{anchor:projection(Cone P, Int> indices):}} **''projection(Cone P, Int> indices)''**
-  * //Parameters:
-/polytope/objects/Cone ''P'' : \\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Int> ''indices'' : \\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ project the 3-cube along the first coordinate, i.e. to the subspace spanned by the second and third coordinate: \\ <code> >  $p = projection(cube(3),[1],revert=>1);
- print $p->VERTICES;
-1 -1
-1 1
--1 1
--1 -1
-</code>
-{{anchor:lattice_pyramid(Polytope P, Rational z, Vector v):}} **''lattice_pyramid(Polytope P, Rational z, Vector v)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Rational ''z'' : the height for the apex (//v//,//z//), default value is 1.
-\\ /common/property_types/Algebraic Types/Vector ''v'' : the lattice point to use as apex, default is the first vertex of //P//.
-\\
-  * //Returns:// /polytope/objects/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//.
-  * //Example://\\ To create the pyramid of height 5 over a square and keep the vertex labels, do this: \\ <code> >  $p = lattice_pyramid(cube(2),5,new Vector(1,0,0));
- print $p->VERTICES;
--1 -1 0
-1 -1 0
--1 1 0
-1 1 0
-0 0 5
-</code>\\  \\ <code> >  print $p->VERTEX_LABELS;
-1 2 3 Apex
-</code>
-{{anchor:stellar_indep_faces(Polytope P, Int>> in_faces):}} **''stellar_indep_faces(Polytope P, Int>> in_faces)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : , must be bounded
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>> ''in_faces'' : \\
-  * //Returns:// /polytope/objects/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.
-{{anchor:rand_vert(Matrix V, Int n):}} **''rand_vert(Matrix V, Int n)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''V'' : the vertices of a polytope
-\\ /common/property_types/Basic Types/Int ''n'' : the number of random points
-\\
-  * //Returns:// /common/property_types/Algebraic Types/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.
-{{anchor:conv(Polytope> P_Array):}} **''conv(Polytope> P_Array)''**
-  * //Parameters:
-/common/property_types/Basic Types/Array</polytope/objects/Polytope> ''P_Array'' : \\
-  * //Returns:// /polytope/objects/PropagatedPolytope
-  *      Construct a new polyhedron as the convex hull of the polyhedra\\     given in //P_Array//.
-  * //Example://\\  \\ <code> >  $p = conv([cube(2,1,0),cube(2,6,5)]);
- print $p->VERTICES;
-0 0
-1 0
-0 1
-6 5
-5 6
-6 6
-</code>
-{{anchor:stack(Polytope P, Int> stack_facets):}} **''stack(Polytope P, Int> stack_facets)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Set Types/Set</common/property_types/Basic Types/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.
-\\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ To generate a cubical polytope by stacking all facets of the 3-cube to height 1/4, do this: \\ <code> >  $p = stack(cube(3),All,lift=>1/4);
-</code>
-{{anchor:integer_hull(Polytope P):}} **''integer_hull(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces the integer hull of a polyhedron
-  * //Example://\\  \\ <code> >  $p = new Polytope(VERTICES=>[[1,13/10,1/2],[1,1/5,6/5],[1,1/10,-3/2],[1,-7/5,1/5]]);
- $ih = integer_hull($p);
- print $ih->VERTICES;
--1 0
-0 -1
-0 1
-1 0
-</code>
-----
-==== 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.
-{{anchor:lecture_hall_simplex(Int d):}} **''lecture_hall_simplex(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a lecture hall //d//-simplex.
-  * //Example://\\ To create the 2-dimensional lecture hall simplex and compute its symmetry group, type this: \\ <code> >  $p = lecture_hall_simplex(2, group=>1);
- print $p->GROUP->RAYS_ACTION->GENERATORS;
-0 2
-0 1
-</code>
-{{anchor:zonotope(Scalar> M):}} **''zonotope(Scalar> M)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix</polytope/functions/Producing a polytope from scratch/zonotope/tparams/Scalar> ''M'' : input points or vectors
-\\
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing a polytope from scratch/zonotope/tparams/Scalar>
-  *      Create a zonotope from a matrix whose rows are input points or vectors.\\    \\     This method merely defines a Polytope object with the property\\     [[/polytope/objects/Polytope/properties/Geometry/ZONOTOPE_INPUT_POINTS]].
-  * //Example://\\ The following produces a parallelogram with the origin as its vertex barycenter: \\ <code> >  $M = new Matrix([[1,1,0],[1,1,1]]);
- $p = zonotope($M);
- print $p->VERTICES;
-0 -1/2
-0 1/2
--1 -1/2
-1 1/2
-</code>
-  * //Example://\\ The following produces a parallelogram with the origin being a vertex (not centered case): \\ <code> >  $M = new Matrix([[1,1,0],[1,1,1]]);
- $p = zonotope($M,centered=>0);
- print $p->VERTICES;
-1 0
-0 0
-1 1
-2 1
-</code>
-{{anchor:dwarfed_product_polygons(Int d, Int s):}} **''dwarfed_product_polygons(Int d, Int s)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''s'' : the size
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional dwarfed product of polygons of size //s//.
-{{anchor:signed_permutahedron(Int d):}} **''signed_permutahedron(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional signed permutahedron.
-{{anchor:n_gon(Int n, Rational r, Rational alpha_0):}} **''n_gon(Int n, Rational r, Rational alpha_0)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''n'' : the number of vertices
-\\ /common/property_types/Basic Types/Rational ''r'' : the radius (defaults to 1)
-\\ /common/property_types/Basic Types/Rational ''alpha_0'' : the initial angle divided by pi (defaults to 0)
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a regular //n//-gon.\\     All vertices lie on a circle of radius //r//.\\     The radius defaults to 1.
-  * //Example://\\ To store the regular pentagon in the variable $p and calculate its symmetry group, do this: \\ <code> >  $p = n_gon(5,group=>1);
- print $p->GROUP->RAYS_ACTION->GENERATORS;
-4 3 2 1
-2 3 4 0
-</code>
-{{anchor:rand01(Int d, Int n):}} **''rand01(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : the number of random vertices
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional 0/1-polytope with //n// random vertices.\\     Uniform distribution.
-{{anchor:pile(Int> sizes):}} **''pile(Int> sizes)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Int> ''sizes'' : a vector (s<sub>1</sub>,...,s<sub>d</sub>,
-   where s<sub>i</sub> specifies the number of boxes in the i-th dimension.
-\\
-  * //Returns:// /polytope/objects/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.
-{{anchor:upper_bound_theorem(Int d, Int n):}} **''upper_bound_theorem(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : the number of points
-\\
-  * //Returns:// /polytope/objects/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 [[/polytope/objects/Polytope/properties/Combinatorics/H_VECTOR]] and the [[/polytope/objects/Polytope/properties/Combinatorics/F_VECTOR]].
-  * //Example://\\ This produces the combinatorial data as mentioned above for 5 points in dimension 3 and prints the h-vector: \\ <code> >  $p = upper_bound_theorem(3,5);
- print $p->H_VECTOR;
-2 2 1
-</code>
-{{anchor:perturbed_long_and_winding(Int r):}} **''perturbed_long_and_winding(Int r)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''r'' : defining parameter
-\\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Algebraic Types/PuiseuxFraction</common/property_types/Arithmetic/Max, /common/property_types/Basic Types/Rational, /common/property_types/Basic Types/Rational> >
-  *      Produce polytope in dimension 2r with 3r+2 facets such that the total curvature\\     of the central path is at least Omega(2^r).\\     This is a perturbed version of [[/polytope/functions/Producing a polytope from scratch/long_and_winding]], which yields simple polytopes.
-  * //Example://\\ This yields a simple 4-polytope over the field of Puiseux fractions. \\ <code> >  $p = perturbed_long_and_winding(2);
-</code>
-{{anchor:klee_minty_cube(Int d, Scalar e):}} **''klee_minty_cube(Int d, Scalar e)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/klee_minty_cube/tparams/Scalar ''e'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produces a //d//-dimensional Klee-Minty-cube if //e//<1/2.\\     Uses the [[/polytope/functions/Producing a polytope from scratch/goldfarb]] client with //g//=0.
-{{anchor:cyclic_caratheodory(Int d, Int n):}} **''cyclic_caratheodory(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension. Required to be even.
-\\ /common/property_types/Basic Types/Int ''n'' : the number of points
-\\
-  * //Returns:// /polytope/objects/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/functions/Producing a polytope from scratch/cyclic]].
-{{anchor:associahedron(Int d):}} **''associahedron(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional associahedron (or Stasheff polytope).\\     We use the facet description given in Ziegler's book on polytopes, section 9.2.
-{{anchor:newton(Polynomial p):}} **''newton(Polynomial p)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Polynomial ''p'' : \\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Basic Types/Rational>
-  *      Produce the Newton polytope of a polynomial //p//.
-  * //Example://\\ Create the newton polytope of 1+x^2+y like so: \\ <code> >  local_var_names<Polynomial>(qw(x y));  $p=new Polynomial('1+x^2+y');
- $n = newton($p);
- print $n->VERTICES;
-0 0
-0 1
-2 0
-</code>
-{{anchor:fractional_knapsack(Rational> b):}} **''fractional_knapsack(Rational> b)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Rational> ''b'' : linear inequality
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a knapsack polytope defined by one linear inequality (and non-negativity constraints).
-{{anchor:permutahedron(Int d):}} **''permutahedron(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional permutahedron.\\     The vertices correspond to the elements of the symmetric group of degree //d//+1.
-  * //Example://\\ To create the 3-permutahedron and also compute its symmetry group, do this: \\ <code> >  $p = permutahedron(3,group=>1);
- print $p->GROUP->COORDINATE_ACTION->GENERATORS;
-0 2 3
-0 1 2
-</code>
-{{anchor:multiplex(Int d, Int n):}} **''multiplex(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : \\
-  * //Returns:// /polytope/objects/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.
-{{anchor:hypertruncated_cube<Scalar>:}} **''hypertruncated_cube<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : Coordinate type of the resulting polytope.  Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing a polytope from scratch/hypertruncated_cube/tparams/Scalar>
-  *      Produce a //d//-dimensional hypertruncated cube.\\     With symmetric linear objective function (0,1,1,...,1).
-{{anchor:goldfarb(Int d, Scalar e, Scalar g):}} **''goldfarb(Int d, Scalar e, Scalar g)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/goldfarb/tparams/Scalar ''e'' : \\ /polytope/functions/Producing a polytope from scratch/goldfarb/tparams/Scalar ''g'' : \\
-  * //Returns:// /polytope/objects/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.
-{{anchor:rand_metric_int<Scalar>:}} **''rand_metric_int<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : element type of the result matrix
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Produce an //n//-point metric with random distances. The values are uniformily\\     distributed in [1,2].
-{{anchor:simplex(Int d, Scalar scale):}} **''simplex(Int d, Scalar scale)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/simplex/tparams/Scalar ''scale'' : default value: 1
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce the standard //d//-simplex.\\     Combinatorially equivalent to a regular polytope corresponding to the Coxeter group of type A<sub>//d//-1</sub>.\\     Optionally, the simplex can be scaled by the parameter //scale//.
-  * //Example://\\ To print the vertices (in homogeneous coordinates) of the standard 2-simplex, i.e. a right-angled isoceles triangle, type this: \\ <code> >  print simplex(2)->VERTICES;
- (3) (0 1)
-1 0
-0 1
-</code>\\  The first row vector is sparse and encodes the origin. \\
-  * //Example://\\ To create a 3-simplex and also calculate its symmetry group, type this: \\ <code> >  simplex(3, group=>1);
-</code>
-{{anchor:rss_associahedron(Int l):}} **''rss_associahedron(Int l)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''l'' : ambient dimension
-\\
-  * //Returns:// /polytope/objects/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.
-{{anchor:birkhoff(Int n, Bool even):}} **''birkhoff(Int n, Bool even)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''n'' : \\ /common/property_types/Basic Types/Bool ''even'' : Defaults to '0'. Set this to '1' to get vertices only for even permutation matrices.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Constructs the Birkhoff polytope of dimension //n//<sup>2</sup>. It is the polytope of\\     //n//x//n// stochastic matrices (encoded as //n//<sup>2</sup> row vectors), thus matrices\\     with non-negative entries whose row and column entries sum up to one.\\     Its vertices are the permutation matrices.
-{{anchor:zonotope_vertices_fukuda(Matrix M):}} **''zonotope_vertices_fukuda(Matrix M)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''M'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Create the vertices of a zonotope from a matrix whose rows are input points or vectors.
-  * //Example://\\ The following stores the vertices of a parallelogram with the origin as its vertex barycenter and prints them: \\ <code> >  $M = new Matrix([[1,1,0],[1,1,1]]);
- print zonotope_vertices_fukuda($M);
-0 -1/2
-0 1/2
--1 -1/2
-1 1/2
-</code>
-{{anchor:dwarfed_cube(Int d):}} **''dwarfed_cube(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional dwarfed cube.
-{{anchor:explicit_zonotope(Matrix zones):}} **''explicit_zonotope(Matrix zones)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''zones'' : the input vectors
-\\
-  * //Returns:// /polytope/objects/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//.
-  * //Example://\\  \\ <code> >  $M = new Matrix([1,1],[1,-1]);
- $p = explicit_zonotope($M,rows_are_points=>0);
- print $p->VERTICES;
-2 0
-0 -2
-0 2
--2 0
-</code>
-{{anchor:binary_markov_graph:}} **''binary_markov_graph''**
-{{anchor:k_cyclic(Int n, Vector s):}} **''k_cyclic(Int n, Vector s)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''n'' : the number of points
-\\ /common/property_types/Algebraic Types/Vector ''s'' : s=(s_1,...,s_k)
-\\
-  * //Returns:// /polytope/objects/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&pi;i/n),\\    	 sin(s_1 * 2&pi;i/n),\\    	 ...\\    	 cos(s_k * 2&pi;i/n),\\    	 sin(s_k * 2&pi;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
-  * //Example://\\ To produce a (not exactly) regular pentagon, type this: \\ <code> >  $p = k_cyclic(5,[1]);
-</code>
-{{anchor:perles_irrational_8_polytope:}} **''perles_irrational_8_polytope''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create an 8-dimensional polytope without rational realizations due to Perles
-{{anchor:long_and_winding(Int r):}} **''long_and_winding(Int r)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''r'' : defining parameter
-\\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Algebraic Types/PuiseuxFraction</common/property_types/Arithmetic/Max, /common/property_types/Basic Types/Rational, /common/property_types/Basic Types/Rational> >
-  *      Produce polytope in dimension 2r with 3r+2 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 same construction (written in a slightly different form)\\     and its analysis can be found in Allamigeon, Benchimol, Gaubert and Joswig, arXiv:1405.4161\\     See also [[/polytope/functions/Producing a polytope from scratch/perturbed_long_and_winding]].
-  * //Example://\\ This yields a 4-polytope over the field of Puiseux fractions. \\ <code> >  $p = long_and_winding(2);
-</code>
-  * //Example://\\ This yields a rational 4-polytope with the same combinatorics. \\ <code> >  $p = long_and_winding(2,eval_ratio=>2);
-</code>
-{{anchor:rand_sphere(Int d, Int n):}} **''rand_sphere(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : the number of random vertices
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a //d//-dimensional polytope with //n// random vertices\\     uniformly distributed on the unit sphere.
-{{anchor:rand_cyclic(Int d, Int n):}} **''rand_cyclic(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : the number of vertices
-\\
-  * //Returns:// /polytope/objects/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.
-{{anchor:rand_metric<Scalar>:}} **''rand_metric<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : element type of the result matrix
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Produce an //n//-point metric with random distances. The values are uniformily\\     distributed in [1,2].
-{{anchor:neighborly_cubical(Int d, Int n):}} **''neighborly_cubical(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : dimension of the polytope
-\\ /common/property_types/Basic Types/Int ''n'' : dimension of the equivalent cube
-\\
-  * //Returns:// /polytope/objects/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).
-{{anchor:delpezzo(Int d, Scalar scale):}} **''delpezzo(Int d, Scalar scale)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/delpezzo/tparams/Scalar ''scale'' : the absolute value of each non-zero vertex coordinate. Needs to be positive. The default value is 1.
-\\
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing a polytope from scratch/delpezzo/tparams/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.
-{{anchor:max_GC_rank(Int d):}} **''max_GC_rank(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/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.
-{{anchor:fano_simplex(Int d):}} **''fano_simplex(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a Fano //d//-simplex.
-  * //Example://\\ To create the 2-dimensional fano simplex and compute its symmetry group, type this: and print ints generators, do this: \\ <code> >  $p = fano_simplex(2,group=>1);
- print $p->GROUP->RAYS_ACTION->GENERATORS;
-0 2
-0 1
-</code>
-{{anchor:pseudo_delpezzo(Int d, Scalar scale):}} **''pseudo_delpezzo(Int d, Scalar scale)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/pseudo_delpezzo/tparams/Scalar ''scale'' : the absolute value of each non-zero vertex coordinate. Needs to be positive. The default value is 1.
-\\
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing a polytope from scratch/pseudo_delpezzo/tparams/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.
-{{anchor:hypersimplex(Int k, Int d):}} **''hypersimplex(Int k, Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''k'' : number of 1s
-\\ /common/property_types/Basic Types/Int ''d'' : ambient dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce the hypersimplex &Delta;(//k//,//d//), that is the the convex hull of all 0/1-vector in R<sup>//d//</sup>\\     with exactly //k// 1s.\\     Note that the output is never full-dimensional.
-  * //Example://\\ This creates the hypersimplex in dimension 4 with vertices with exactly two 1-entries and computes its symmetry group: \\ <code> >  $h = hypersimplex(2,4,group=>1);
-</code>
-{{anchor:stable_set(Graph G):}} **''stable_set(Graph G)''**
-  * //Parameters:
-/graph/objects/Combinatorics/Graph ''G'' : \\
-  * //Returns:// /polytope/objects/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
-{{anchor:rand_box(Int d, Int n, Int b):}} **''rand_box(Int d, Int n, Int b)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the box
-\\ /common/property_types/Basic Types/Int ''n'' : the number of random points
-\\ /common/property_types/Basic Types/Int ''b'' : the size of the box
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Computes the convex hull of //n// points sampled uniformly at random from the\\     integer points in the cube [0,//b//]<sup>//d//</sup>.
-{{anchor:cyclic(Int d, Int n):}} **''cyclic(Int d, Int n)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /common/property_types/Basic Types/Int ''n'' : the number of points
-\\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Basic Types/Rational>
-  *      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.
-  * //Example://\\ To create the 2-dimensional cyclic polytope with 6 points on the sphere, starting at 3: \\ <code> >  $p = cyclic(2,6,start=>3,spherical=>1);
- print $p->VERTICES;
-1/10 3/10
-1/17 4/17
-1/26 5/26
-1/37 6/37
-1/50 7/50
-1/65 8/65
-</code>
-{{anchor:goldfarb_sit(Int d, Scalar eps, Scalar delta):}} **''goldfarb_sit(Int d, Scalar eps, Scalar delta)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\ /polytope/functions/Producing a polytope from scratch/goldfarb_sit/tparams/Scalar ''eps'' : \\ /polytope/functions/Producing a polytope from scratch/goldfarb_sit/tparams/Scalar ''delta'' : \\
-  * //Returns:// /polytope/objects/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.
-{{anchor:transportation(Vector r, Vector c):}} **''transportation(Vector r, Vector c)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector ''r'' : \\ /common/property_types/Algebraic Types/Vector ''c'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce the transportation polytope from two vectors //r// of length m and //c// of length n,\\     i.e. all positive m&times;n Matrizes with row sums equal to //r// and column sums equal to //c//.
-----
-==== Producing a vector configuration ====
- A way of constructing vector configurations is to modify an
- already existing vector configuration.
-{{anchor:project_to:}} **''project_to''**
-{{anchor:projection_preimage<Scalar>:}} **''projection_preimage<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : coordinate type
-  * //Returns:// /polytope/objects/Geometry/VectorConfiguration
-  *      Construct a new vector configuration that projects to a given array of vector configurations\\     If the n vector configurations are d_1, d_2, ..., d_n-dimensional and all have m vectors,\\     the resulting vector configuration is (d_1+...+d_n)-dimensional, has m vectors, and\\     the projection to the i-th d_i coordinates gives the i-th input vector configuration.
-{{anchor:project_out:}} **''project_out''**
-{{anchor:free_sum(VectorConfiguration P1, VectorConfiguration P2):}} **''free_sum(VectorConfiguration P1, VectorConfiguration P2)''**
-  * //Parameters:
-/polytope/objects/Geometry/VectorConfiguration ''P1'' : \\ /polytope/objects/Geometry/VectorConfiguration ''P2'' : \\
-  * //Returns:// /polytope/objects/Geometry/VectorConfiguration
-  *      Construct the free sum of two vector configurations.
-{{anchor:project_full<Scalar>:}} **''project_full<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : coordinate type
-  * //Returns:// /polytope/objects/Geometry/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.
-{{anchor:projection<Scalar>:}} **''projection<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : coordinate type
-  * //Returns:// /polytope/objects/Geometry/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.
-----
-==== Producing other objects ====
- Functions producing big objects which are not contained in application polytope.
-{{anchor:crosscut_complex(Polytope p):}} **''crosscut_complex(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\
-  * //Returns:// /topaz/objects/SimplicialComplex
-  *      Produce the __crosscut complex__ of the boundary of a polytope.
-{{anchor:coxeter_group(String type):}} **''coxeter_group(String type)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''type'' : the type of the Coxeter group
-\\
-  * //Returns:// /group/objects/Group
-  *      Produces the Coxeter group of type //type//. \\     The Dynkin diagrams of the different types can be\\     found in the description of the clients [[/polytope/functions/Producing regular polytopes and their generalizations/simple_roots_type_A|simple_roots_type_*]].
-----
-==== 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.
-{{anchor:simple_roots_type_F4:}} **''simple_roots_type_F4''**
-  * //Returns:// /common/property_types/Algebraic Types/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
-{{anchor:icosahedron:}} **''icosahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact regular icosahedron in Q(sqrt{5}).  A Platonic solid.
-{{anchor:simple_roots_type_E8:}} **''simple_roots_type_E8''**
-  * //Returns:// /common/property_types/Algebraic Types/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.
-{{anchor:simple_roots_type_G2:}} **''simple_roots_type_G2''**
-  * //Returns:// /common/property_types/Algebraic Types/SparseMatrix
-  *      Produce the simple roots of the Coxeter arrangement of type G2\\     Indices are taken w.r.t. the Dynkin diagram  0 <--(6)-- 1
-{{anchor:simple_roots_type_H3:}} **''simple_roots_type_H3''**
-  * //Returns:// /common/property_types/Algebraic Types/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
-{{anchor:truncated_icosidodecahedron:}} **''truncated_icosidodecahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact truncated icosidodecahedron in Q(sqrt{5}).  An Archimedean solid.
-{{anchor:platonic_solid(String s):}} **''platonic_solid(String s)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''s'' : the name of the desired Platonic solid
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Create Platonic solid of the given name.
-{{anchor:root_system(String type):}} **''root_system(String type)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''type'' : the type of the Coxeter arrangement, for example A4 or E8
-\\
-  * //Returns:// /polytope/objects/Geometry/VectorConfiguration
-  *      Produce the root systems of the Coxeter arrangement of a given type\\     The roots lie at infinity to facilitate reflecting in them.
-{{anchor:cross<Scalar>:}} **''cross<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : Coordinate type of the resulting polytope.  Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing regular polytopes and their generalizations/cross/tparams/Scalar>
-  *      Produce a //d//-dimensional cross polytope.\\     Regular polytope corresponding to the Coxeter group of type B<sub>//d//-1</sub> = C<sub>//d//-1</sub>.\\    \\     All coordinates are +/- //scale// or 0.
-  * //Example://\\ To create the 3-dimensional cross polytope, type \\ <code> >  $p = cross(3);
-</code>\\  Check out it's vertices and volume: \\ <code> >  print $p->VERTICES;
-1 0 0
--1 0 0
-0 1 0
-0 -1 0
-0 0 1
-0 0 -1
-</code>\\  \\ <code> >  print cross(3)->VOLUME;
-/3
-</code>\\  If you rather had a bigger one, type \\ <code> >  $p_scaled = cross(3,2);
- print $p_scaled->VOLUME;
-/3
-</code>\\  To also calculate the symmetry group, do this: \\ <code> >  $p = cross(3,group=>1);
-</code>\\  You can then print the generators of this group like this: \\ <code> >  print $p->GROUP->RAYS_ACTION->GENERATORS;
-0 2 3 4 5
-3 0 1 4 5
-1 4 5 2 3
-</code>
-{{anchor:regular_simplex(Int d):}} **''regular_simplex(Int d)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a regular //d//-simplex embedded in R^d with edge length sqrt(2).
-  * //Example://\\ To print the vertices (in homogeneous coordinates) of the regular 2-simplex, i.e. an equilateral triangle, type this: \\ <code> >  print regular_simplex(2)->VERTICES;
-1 0
-0 1
-1/2-1/2r3 1/2-1/2r3
-</code>\\  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)). \\
-  * //Example://\\ To store a regular 3-simplex in the variable $s and also calculate its symmetry group, type this: \\ <code> >  $s = regular_simplex(3, group=>1);
-</code>\\  You can then print the groups generators like so: \\ <code> >  print $s->GROUP->RAYS_ACTION->GENERATORS;
-0 2 3
-0 1 2
-</code>
-{{anchor:reduced(Rational t, Rational x, Rational s, Rational h, Rational r):}} **''reduced(Rational t, Rational x, Rational s, Rational h, Rational r)''**
-  * //Parameters:
-/common/property_types/Basic Types/Rational ''t'' : \\ /common/property_types/Basic Types/Rational ''x'' : \\ /common/property_types/Basic Types/Rational ''s'' : \\ /common/property_types/Basic Types/Rational ''h'' : \\ /common/property_types/Basic Types/Rational ''r'' : \\
-  * //Returns:// /polytope/objects/Polytope</common/property_types/Basic Types/Rational>
-  *      Produce a 3-dimensional reduced polytope (for suitably chosen parameters).\\     That is, a polytope of constant width which does not properly contain a subpolytope of the same width.\\     Construction due to Bernardo González Merino, Thomas Jahn, Alexandr Polyanskii and Gerd Wachsmuth, arXiv:1701.08629
-  * //Example://\\ These values yield a reduced 3-polytope (approximately).  The width equals 1. \\ <code> >  $r = reduced(0.55, 0.6176490959800, 0.1351384931026, 0.0984300252409, 0.3547183586709);
-</code>
-{{anchor:regular_120_cell:}} **''regular_120_cell''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact regular 120-cell in Q(sqrt{5}).
-{{anchor:rhombicuboctahedron:}} **''rhombicuboctahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create rhombicuboctahedron.  An Archimedean solid.
-{{anchor:simple_roots_type_C(Int index):}} **''simple_roots_type_C(Int index)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''index'' : of the arrangement (3, 4, etc)
-\\
-  * //Returns:// /common/property_types/Algebraic Types/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}.
-{{anchor:truncated_cube:}} **''truncated_cube''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create truncated cube.  An Archimedean solid.
-{{anchor:truncated_dodecahedron:}} **''truncated_dodecahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact truncated dodecahedron in Q(sqrt{5}).  An Archimedean solid.
-{{anchor:truncated_icosahedron:}} **''truncated_icosahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact truncated icosahedron in Q(sqrt{5}).  An Archimedean solid.\\     Also known as the soccer ball.
-{{anchor:simple_roots_type_B(Int index):}} **''simple_roots_type_B(Int index)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''index'' : of the arrangement (3, 4, etc)
-\\
-  * //Returns:// /common/property_types/Algebraic Types/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}.
-{{anchor:simple_roots_type_E7:}} **''simple_roots_type_E7''**
-  * //Returns:// /common/property_types/Algebraic Types/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.
-{{anchor:simple_roots_type_D(Int index):}} **''simple_roots_type_D(Int index)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''index'' : of the arrangement (3, 4, etc)
-\\
-  * //Returns:// /common/property_types/Algebraic Types/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}.
-{{anchor:rhombicosidodecahedron:}} **''rhombicosidodecahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact rhombicosidodecahedron in Q(sqrt{5}).  An Archimedean solid.
-{{anchor:tetrahedron:}} **''tetrahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create regular tetrahedron.  A Platonic solid.
-{{anchor:regular_24_cell:}} **''regular_24_cell''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create regular 24-cell.
-{{anchor:wythoff(String type, Set rings):}} **''wythoff(String type, Set rings)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''type'' : single letter followed by rank representing the type of the arrangement
-\\ /common/property_types/Set Types/Set ''rings'' : indices of the hyperplanes corresponding to simple roots of the arrangement
- that the initial point should NOT lie on. You may specify just an integer or a perl array ref like [0,1] or [0..2].
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce the orbit polytope of a point under a Coxeter arrangement\\     with exact coordinates, possibly in a qudratic extension field of the rationals
-{{anchor:cuboctahedron:}} **''cuboctahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create cuboctahedron.  An Archimedean solid.
-{{anchor:icosidodecahedron:}} **''icosidodecahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact icosidodecahedron in Q(sqrt{5}).  An Archimedean solid.
-{{anchor:simple_roots_type_E6:}} **''simple_roots_type_E6''**
-  * //Returns:// /common/property_types/Algebraic Types/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.
-{{anchor:truncated_octahedron:}} **''truncated_octahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create truncated octahedron.  An Archimedean solid.\\     Also known as the 3-permutahedron.
-{{anchor:johnson_solid:}} **''johnson_solid''**
-{{anchor:archimedean_solid(String s):}} **''archimedean_solid(String s)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''s'' : the name of the desired Archimedean solid
-\\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ To show the mirror image of the snub cube use: \\ <code> >  scale(archimedean_solid('snub_cube'),-1)->VISUAL;
-</code>
-{{anchor:dodecahedron:}} **''dodecahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact regular dodecahedron in Q(sqrt{5}).  A Platonic solid.
-{{anchor:simple_roots_type_A(Int index):}} **''simple_roots_type_A(Int index)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''index'' : of the arrangement (3, 4, etc)
-\\
-  * //Returns:// /common/property_types/Algebraic Types/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}.
-{{anchor:simple_roots_type_H4:}} **''simple_roots_type_H4''**
-  * //Returns:// /common/property_types/Algebraic Types/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}
-{{anchor:cube<Scalar>:}} **''cube<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : Coordinate type of the resulting polytope.  Unless specified explicitly, deduced from the type of bound values, defaults to Rational.
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Producing regular polytopes and their generalizations/cube/tparams/Scalar>
-  *      Produce a //d//-dimensional cube.\\     Regular polytope corresponding to the Coxeter group of type B<sub>//d//-1</sub> = C<sub>//d//-1</sub>.\\    \\     The bounding hyperplanes are x<sub>i</sub> <= //x_up// and x<sub>i</sub> >= //x_low//.
-  * //Example://\\ This yields a +/-1 cube of dimension 3 and stores it in the variable $c. \\ <code> >  $c = cube(3);
-</code>
-  * //Example://\\ This stores a standard unit cube of dimension 3 in the variable $c. \\ <code> >  $c = cube(3,0);
-</code>
-  * //Example://\\ This prints the area of a square with side length 4 translated to have its vertex barycenter at [5,5]: \\ <code> >  print cube(2,7,3)->VOLUME;
-</code>
-{{anchor:regular_600_cell:}} **''regular_600_cell''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Create exact regular 600-cell in Q(sqrt{5}).
-{{anchor:octahedron:}} **''octahedron''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Produce a regular octahedron, which is the same as the 3-dimensional cross polytope.
-{{anchor:truncated_cuboctahedron:}} **''truncated_cuboctahedron''**
-  * //Returns:// /polytope/objects/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.
-{{anchor:catalan_solid(String s):}} **''catalan_solid(String s)''**
-  * //Parameters:
-/common/property_types/Basic Types/String ''s'' : the name of the desired Catalan solid
-\\
-  * //Returns:// /polytope/objects/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.
-----
-==== Quotient spaces ====
- Topologic cell complexes defined as quotients over polytopes modulo a discrete group.
-{{anchor:davis_manifold:}} **''davis_manifold''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Return the 4-dimensional hyperbolic manifold obtained by Michael Davis
-  * //Example://\\ The Davis manifold is the centrally symmetric quotient of the regular 210-cell: \\ <code> >  $d = davis_manifold();
- print $d->F_VECTOR;
-1200 720 120
-</code>\\  \\ <code> >  print $d->QUOTIENT_SPACE->F_VECTOR;
-600 360 60 1
-</code>
-{{anchor:write_quotient_space_simplexity_ilp:}} **''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.
-{{anchor:cylinder_2:}} **''cylinder_2''**
-  * //Returns:// /polytope/objects/Polytope
-  *      Return a 2-dimensional __cylinder__ obtained by identifying two opposite sides of a square.
-  * //Example://\\ To obtain a topological space homeomorphic to a cylinder, type \\ <code> >  $p = cylinder_2();
- print $p->QUOTIENT_SPACE->IDENTIFICATION_ACTION->GENERATORS;
-3 0 1
-</code>\\  \\ <code> >  print $p->QUOTIENT_SPACE->IDENTIFICATION_ACTION->ORBITS;
- {0 2}
- {1 3}
-</code>\\  Thus, vertices 0,2 and vertices 1,3 are identified. \\ <code> >  print $p->QUOTIENT_SPACE->FACES;
- {{0} {1}}
- {{0 1} {0 2} {1 3}}
- {{0 1 2 3}}
-</code>\\  Thus, after identification two vertices, three edges, and one two-dimensional face remain: \\ <code> >  print $p->QUOTIENT_SPACE->F_VECTOR;
-3 1
-</code>
-{{anchor:cs_quotient(Polytope P):}} **''cs_quotient(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : , centrally symmetric
-\\
-  *      For a centrally symmetric polytope, divide\\     out the central symmetry, i.e, identify diametrically opposite faces.
-  * //Example://\\  \\ <code> >  $P = cube(3);
- cs_quotient($P);
- print $P->CS_PERMUTATION;
-6 5 4 3 2 1 0
-</code>\\  The zeroth vertex gets identified with the seventh, the first with the sixth etc. \\
-{{anchor:quarter_turn_manifold:}} **''quarter_turn_manifold''**
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ To obtain a topological space homeomorphic to the quarter turn manifold, type \\ <code> >  $p = quarter_turn_manifold();
- print $p->QUOTIENT_SPACE->IDENTIFICATION_ACTION->GENERATORS;
-7 4 6 2 0 3 1
-2 1 5 7 3 0 4
-</code>\\  To see which vertices are identified, type \\ <code> >  print $p->QUOTIENT_SPACE->IDENTIFICATION_ACTION->ORBITS;
- {0 3 5 6}
- {1 2 4 7}
-</code>\\  Thus, two classes of vertices remain, with 0 and 1 being representatives.  To see the faces remaining after identification, type \\ <code> >  print $p->QUOTIENT_SPACE->FACES;
- {{0} {1}}
- {{0 1} {0 2} {0 4} {0 7}}
- {{0 1 2 3} {0 1 4 5} {0 1 6 7}}
- {{0 1 2 3 4 5 6 7}}
-</code>\\  \\ <code> >  print $p->QUOTIENT_SPACE->F_VECTOR;
-4 3 1
-</code>
-----
-==== Symmetry ====
- These functions capture information of the object that is concerned with the action of permutation groups.
-{{anchor:symmetrized_cocircuit_equations<Scalar>:}} **''symmetrized_cocircuit_equations<Scalar>''**
-  * //Template Parameters://
-    * ''Scalar'' : the underlying data type
-  *      calculate the projection of the cocircuit equations to a direct sum of isotypic components
-{{anchor:nestedOPGraph(Vector gen_point, Matrix points, Matrix lattice_points, Group group, Bool verbose):}} **''nestedOPGraph(Vector gen_point, Matrix points, Matrix lattice_points, Group group, Bool verbose)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Vector ''gen_point'' : the generating point
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the vertices of the orbit polytope
-\\ /common/property_types/Algebraic Types/Matrix ''lattice_points'' : the lattice points of the orbit polytope
-\\ /group/objects/Group ''group'' : the generating group
-\\ /common/property_types/Basic Types/Bool ''verbose'' : print out additional information
-\\
-  * //Returns:// ARRAY
-  *      Constructs the NOP-graph of an orbit polytope.\\     It is used by the rule for the [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/NOP_GRAPH]].
-{{anchor:linear_symmetries:}} **''linear_symmetries''**
-{{anchor:ortho_project(Polytope p):}} **''ortho_project(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : the symmetric polytope to be projected
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Projects a symmetric polytope in R<sup>4</sup> cap H<sub>1,k</sub> to R<sup>3</sup>.\\     (See also the polymake extension 'tropmat' by S. Horn.)
-{{anchor:combinatorial_symmetrized_cocircuit_equations:}} **''combinatorial_symmetrized_cocircuit_equations''**
-{{anchor:isotypic_configuration(Polytope P, Int i):}} **''isotypic_configuration(Polytope P, Int i)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : a polytope with a matrix action, or a group::Group g with a permutation action
-\\ /common/property_types/Basic Types/Int ''i'' : the index of the desired isotypic component
-\\
-  * //Returns:// /polytope/objects/PointConfiguration</common/property_types/Basic Types/Float>
-  *      Given a polytope that has a matrix group acting on it, return the projections of the vertices to the //i//-th isotypic component //C_i//.\\     If the input is a group with a permutation action //a//, regard //a// as acting on the unit basis vectors of the ambient space\\     and return the projection of the unit basis vectors to the //i//-th isotypic component.
-  * //Example://\\ Consider the symmetry group of the cyclic polytope c(4,10) in the Carathéodory realization. \\ <code> >  $p = cyclic_caratheodory(4,10,group=>1);
-</code>\\  For i=4, we obtain a 10-gon: \\ <code> >  print isotypic_configuration($p,4)->POINTS;
-1 0
-0.8090169944 0.5877852523
-0.3090169944 0.9510565163
--0.3090169944 0.9510565163
--0.8090169944 0.5877852523
--1 0
--0.8090169944 -0.5877852523
--0.3090169944 -0.9510565163
-0.3090169944 -0.9510565163
-0.8090169944 -0.5877852523
-</code>\\  Similarly, for i=5 we get two copies of a pentagon. \\
-{{anchor:combinatorial_symmetries(Polytope p):}} **''combinatorial_symmetries(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : \\
-  * //Returns:// /group/objects/PermutationAction
-  *      Compute the combinatorial symmetries (i.e., automorphisms of the face lattice) of\\     a given polytope //p//. They are stored in terms of a GROUP.VERTICES_ACTION and a GROUP.FACETS_ACTION\\     property in //p//, and the GROUP.VERTICES_ACTION is also returned.
-  * //Example://\\ To get the vertex symmetry group of the square and print its generators, type the following: \\ <code> >  print combinatorial_symmetries(cube(2))->GENERATORS;
-3 0 1
-0 2 3
-</code>\\  \\ <code> >  $p = cube(2); combinatorial_symmetries($p);
- print $p->GROUP->VERTICES_ACTION->GENERATORS;
-2 1 3
-0 3 2
-</code>\\  \\ <code> >  print $p->GROUP->FACETS_ACTION->GENERATORS;
-3 0 1
-0 2 3
-</code>
-{{anchor:cocircuit_equations_support_reps(Scalar> points, Int>> gens, SetType> rirs, SetType> rmis):}} **''cocircuit_equations_support_reps(Scalar> points, Int>> gens, SetType> rirs, SetType> rmis)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix</polytope/functions/Symmetry/cocircuit_equations_support_reps/tparams/Scalar> ''points'' : \\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>> ''gens'' : the generators of the action of the symmetry group
-\\ /common/property_types/Basic Types/Array</polytope/functions/Symmetry/cocircuit_equations_support_reps/tparams/SetType> ''rirs'' : representatives of interior ridge simplices
-\\ /common/property_types/Basic Types/Array</polytope/functions/Symmetry/cocircuit_equations_support_reps/tparams/SetType> ''rmis'' : representatives of maximal interior simplices
-\\
-  * //Returns:// /common/property_types/Basic Types/Int
-  *      write the indices of the representatives of the support of the cocircuit equations to a file
-{{anchor:lattice_automorphisms_smooth_polytope(Polytope P):}} **''lattice_automorphisms_smooth_polytope(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the given polytope
-\\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>>
-  *      Returns a generating set for the lattice automorphism group of a smooth polytope //P//\\     by comparing lattice distances between vertices and facets.
-  * //Example://\\  \\ <code> >  print lattice_automorphisms_smooth_polytope(cube(2));
-3 0 1
-0 3 2
-2 1 3
-</code>
-{{anchor:representation_conversion_up_to_symmetry(Cone c):}} **''representation_conversion_up_to_symmetry(Cone c)''**
-  * //Parameters:
-/polytope/objects/Cone ''c'' : the cone (or polytope) whose dual description is to be computed, equipped with a GROUP
-\\
-  * //Returns:// /common/property_types/Basic Types/Pair
-  *      Computes the dual description of a polytope up to its linear symmetry group.
-{{anchor:truncated_orbit_polytope(Polytope P, Scalar eps):}} **''truncated_orbit_polytope(Polytope P, Scalar eps)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the input polytope
-\\ /polytope/functions/Symmetry/truncated_orbit_polytope/tparams/Scalar ''eps'' : scaled distance by which the vertices of the orbit polytope are to be cut off
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Gives an implicit representation of the all-vertex truncation of an orbit polytope //P//,\\     in which all vertices are cut off by hyperplanes at distance //eps//.\\     The input polytope //P// must have a __GROUP.COORDINATE_ACTION__.\\     The output is a polytope with a __GROUP.COORDINATE_ACTION__ equipped with\\     __INEQUALITIES_GENERATORS__.
-{{anchor:orbit_polytope:}} **''orbit_polytope''**
-----
-==== 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
- [[/polytope/functions/Transformations/orthantify]] - [[/polytope/functions/Transformations/bound]] - [[/polytope/functions/Transformations/center]] - [[/polytope/functions/Transformations/polarize]].
-{{anchor:center(Polytope P):}} **''center(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/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).
-  * //Example://\\ Consider this triangle not containing the origin: \\ <code> >  $P = new Polytope(VERTICES => [[1,1,1],[1,2,1],[1,1,2]]);
- $origin = new Vector([1,0,0]);
- print $P->contains_in_interior($origin);
- false
-</code>\\  To create a translate that contains the origin, do this: \\ <code> >  $PC = center($P);
- print $PC->contains_in_interior($origin);
- true
-</code>\\  This is what happened to the vertices: \\ <code> >  print $PC->VERTICES;
--1/3 -1/3
-2/3 -1/3
--1/3 2/3
-</code>\\  There also exists a property to check whether a polytope is centered: \\ <code> >  print $PC->CENTERED;
- true
-</code>
-{{anchor:polarize(Cone C):}} **''polarize(Cone C)''**
-  * //Parameters:
-/polytope/objects/Cone ''C'' : \\
-  * //Returns:// /polytope/objects/Cone
-  *      This method takes either a polytope (1.) or a cone (2.) as input.\\     1. Given a bounded, centered, not necessarily full-dimensional \\     polytope //P//, produce its polar with respect to the \\     standard Euclidean scalar product.\\     2. Given a cone //C// produce its dual with respect to the \\     standard Euclidean scalar product, i.e. all the vectors \\     that evaluate positively on //C//.\\     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 [[/polytope/functions/Producing a polytope from polytopes/pointed_part]] client afterwards.
-  * //Example://\\ To save the polar of the square in the variable $p and then print its vertices, do this: \\ <code> >  $p = polarize(cube(2));
- print $p->VERTICES;
-1 0
--1 0
-0 1
-0 -1
-</code>
-  * //Example://\\ To dualize the cone over a hexagon and print its rays, do this: \\ <code> >  $c = new Cone(INPUT_RAYS=>[[1,0,0],[1,1,0],[1,2,1],[1,2,2],[1,1,2],[1,0,1]]);
- $cd = polarize($c);
- print $cd->RAYS;
--1 1
-0 1
-1 0
-1 -1
-0 -1/2
--1/2 0
-</code>
-{{anchor:orthonormal_col_basis(Matrix M):}} **''orthonormal_col_basis(Matrix M)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''M'' : the input matrix
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Float>
-  *      Return an orthonormal column basis of the input matrix.
-{{anchor:bound(Polytope P):}} **''bound(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : a positive polyhedron
-\\
-  * //Returns:// /polytope/objects/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 [[/polytope/objects/Cone/properties/Geometry/POSITIVE]]; i.e. no negative coordinates.
-  * //Example://\\ Observe the transformation of a simple unbounded 2-polyhedron: \\ <code> >  $P = new Polytope(VERTICES=>[[1,0,0],[0,1,1],[0,0,1]]);
- print bound($P)->VERTICES;
-0 0
-1/2 1/2
-0 1
-</code>\\  As you can see, the far points are mapped to the hyperplane spanned by (1,1,0) and (1,0,1). \\
-{{anchor:orthantify(Polytope P, Int v):}} **''orthantify(Polytope P, Int v)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\ /common/property_types/Basic Types/Int ''v'' : vertex to be moved to the origin.
-   By default it is the first affine vertex of the polyhedron.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Make a polyhedron [[/polytope/objects/Cone/properties/Geometry/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.
-  * //Example://\\ To orthantify the square, moving its first vertex to the origin, do this: \\ <code> >  $p = orthantify(cube(2),1);
- print $p->VERTICES;
-2 0
-0 0
-2 2
-0 2
-</code>
-{{anchor:revert(Polytope P):}} **''revert(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : a (transformed) polytope
-\\
-  * //Returns:// /polytope/objects/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.
-  * //Example://\\ The following translates the square and then reverts the transformation: \\ <code> >  $v = new Vector(1,2);
- $p = translate(cube(2),$v);
- print $p->VERTICES;
-0 1
-2 1
-0 3
-2 3
-</code>\\  \\ <code> >  $q = revert($p);
- print $q->VERTICES;
--1 -1
-1 -1
--1 1
-1 1
-</code>
-{{anchor:transform(Polytope P, Matrix trans, Bool store):}} **''transform(Polytope P, Matrix trans, Bool store)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the polyhedron to be transformed
-\\ /common/property_types/Algebraic Types/Matrix ''trans'' : the transformation matrix
-\\ /common/property_types/Basic Types/Bool ''store'' : stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION);
-   default value: 1.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Transform a polyhedron //P// according to the linear\\     transformation //trans//.
-  * //Example://\\ This translates the square by (23,23) and stores the transformation: \\ <code> >  $M = new Matrix([1,23,23],[0,1,0],[0,0,1]);
- $p = transform(cube(2),$M,1);
- print $p->VERTICES;
-22 22
-24 22
-22 24
-24 24
-</code>\\  To retrieve the attached transformation, use this: \\ <code> >  print $p->get_attachment('REVERSE_TRANSFORMATION');
--23 -23
-1 0
-0 1
-</code>\\  Check out the __revert__ function to learn how to undo the transformation. It might be more comfortable to use the __translate__ function to achieve the same result. \\
-{{anchor:ambient_lattice_normalization(Polytope p):}} **''ambient_lattice_normalization(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : the input polytope,
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Transform to a full-dimensional polytope while preserving\\     the ambient lattice Z^n
-  * //Example://\\ Consider a line segment embedded in 2-space containing three lattice points: \\ <code> >  $p = new Polytope(VERTICES=>[[1,0,0],[1,2,2]]);
- print ambient_lattice_normalization($p)->VERTICES;
-0
-2
-</code>\\  The ambient lattice of the projection equals the intersection of the affine hull of $p with Z^2. \\
-  * //Example://\\ Another line segment containing only two lattice points: \\ <code> >  $p = new Polytope(VERTICES=>[[1,0,0],[1,1,2]]);
- $P = ambient_lattice_normalization($p,store_transform=>1);
- print $P->VERTICES;
-0
-1
-</code>\\  To get the transformation, do the following: \\ <code> >  $M = $P->get_attachment('REVERSE_LATTICE_PROJECTION');
- print $M;
-0 0
-1 2
-</code>\\  \\ <code> >  print $P->VERTICES * $M;
-0 0
-1 2
-</code>
-{{anchor:translate(Polytope P, Vector trans, Bool store):}} **''translate(Polytope P, Vector trans, Bool store)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the polyhedron to be translated
-\\ /common/property_types/Algebraic Types/Vector ''trans'' : the translation vector
-\\ /common/property_types/Basic Types/Bool ''store'' : stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION);
-   default value: 1.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Translate a polyhedron //P// by a given translation vector //trans//.
-  * //Example://\\ This translates the square by (23,23) and stores the transformation: \\ <code> >  $t = new Vector(23,23);
- $p = translate(cube(2),$t);
- print $p->VERTICES;
-22 22
-24 22
-22 24
-24 24
-</code>\\  To retrieve the attached transformation, use this: \\ <code> >  print $p->get_attachment('REVERSE_TRANSFORMATION');
--23 -23
-1 0
-0 1
-</code>\\  Check out the __revert__ function to learn how to undo the transformation. \\
-{{anchor:vertex_lattice_normalization(Polytope p):}} **''vertex_lattice_normalization(Polytope p)''**
-  * //Parameters:
-/polytope/objects/Polytope ''p'' : the input polytope,
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Transform to a full-dimensional polytope while preserving\\     the lattice spanned by vertices\\     induced lattice of new vertices = Z^dim
-{{anchor:orthonormal_row_basis(Matrix M):}} **''orthonormal_row_basis(Matrix M)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''M'' : the input matrix
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix</common/property_types/Basic Types/Float>
-  *      Return an orthonormal row basis of the input matrix.
-{{anchor:scale(Polytope P, Scalar factor, Bool store):}} **''scale(Polytope P, Scalar factor, Bool store)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the polyhedron to be scaled
-\\ /polytope/functions/Transformations/scale/tparams/Scalar ''factor'' : the scaling factor
-\\ /common/property_types/Basic Types/Bool ''store'' : stores the reverse transformation as an attachment (REVERSE_TRANSFORMATION);
-   default value: 1.
-\\
-  * //Returns:// /polytope/objects/Polytope
-  *      Scale a polyhedron //P// by a given scaling parameter //factor//.
-  * //Example://\\ To scale the square by 23, do this: \\ <code> >  $p = scale(cube(2),23);
- print $p->VERTICES;
--23 -23
-23 -23
--23 23
-23 23
-</code>\\  The transformation matrix is stored in an attachment: \\ <code> >  print $p->get_attachment('REVERSE_TRANSFORMATION');
-0 0
-1/23 0
-0 1/23
-</code>\\  To reverse the transformation, you can use the __revert__ function. \\ <code> >  $q = revert($p);
- print $q->VERTICES;
--1 -1
-1 -1
--1 1
-1 1
-</code>
-----
-==== 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.
-{{anchor:is_regular(Matrix points, Int> > subdiv):}} **''is_regular(Matrix points, Int> > subdiv)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : in homogeneous coordinates
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int> > ''subdiv'' : \\
-  * //Returns:// /common/property_types/Basic Types/Pair</common/property_types/Basic Types/Bool,/common/property_types/Algebraic Types/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//.
-  * //Example://\\ A regular subdivision of the square, with the first cell lifted to zero: \\ <code> >  $points = cube(2)->VERTICES;
- print is_regular($points,[[0,1,3],[1,2,3]],lift_to_zero=>[0,1,3]);
-<0 0 1 0>
-</code>
-{{anchor:universal_polytope:}} **''universal_polytope''**
-{{anchor:barycentric_subdivision(Cone c):}} **''barycentric_subdivision(Cone c)''**
-  * //Parameters:
-/polytope/objects/Cone ''c'' : input cone or polytope
-\\
-  * //Returns:// /topaz/objects/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.
-{{anchor:regular_subdivision(Matrix points, Vector weights):}} **''regular_subdivision(Matrix points, Vector weights)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : \\ /common/property_types/Algebraic Types/Vector ''weights'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/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.
-  * //Example://\\ The following generates a regular subdivision of the square. \\ <code> >  $w = new Vector(2,23,2,2);
- $r = regular_subdivision(cube(2)->VERTICES,$w);
- print $r;
- {0 2 3}
- {0 1 3}
-</code>
-{{anchor:poly2metric(Polytope P):}} **''poly2metric(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/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).
-  * //Example://\\  \\ <code> >  print poly2metric(cube(2), max=>1);
-2 2 2
-0 2 2
-2 0 2
-2 2 0
-</code>
-{{anchor:simplexity_lower_bound(Int d, Matrix points, Scalar volume, SparseMatrix cocircuit_equations):}} **''simplexity_lower_bound(Int d, Matrix points, Scalar volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /polytope/functions/Triangulations, subdivisions and volume/simplexity_lower_bound/tparams/Scalar ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /common/property_types/Basic Types/Integer
-  *      Calculate the LP relaxation lower bound for the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold
-{{anchor:foldable_max_signature_upper_bound(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations):}} **''foldable_max_signature_upper_bound(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /common/property_types/Basic Types/Rational ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /common/property_types/Basic Types/Integer
-  *      Calculate the LP relaxation upper bound to the maximal signature of a foldable triangulation of polytope, point configuration or quotient manifold
-{{anchor:symmetrized_foldable_max_signature_ilp(Int d, Matrix points, Rational volume, Int>> generators, SparseMatrix symmetrized_foldable_cocircuit_equations):}} **''symmetrized_foldable_max_signature_ilp(Int d, Matrix points, Rational volume, Int>> generators, SparseMatrix symmetrized_foldable_cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /common/property_types/Basic Types/Rational ''volume'' : the volume of the convex hull
-\\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>> ''generators'' : the generators of the symmetry group
-\\ /common/property_types/Algebraic Types/SparseMatrix ''symmetrized_foldable_cocircuit_equations'' : the matrix of symmetrized cocircuit equations
-\\
-  * //Returns:// /polytope/objects/Optimization/LinearProgram</common/property_types/Basic Types/Rational>
-  *      Set up an ILP whose MAXIMAL_VALUE is the maximal signature of a foldable triangulation of a polytope, point configuration or quotient manifold
-{{anchor:staircase_weight(Int k, Int l):}} **''staircase_weight(Int k, Int l)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''k'' : the number of vertices of the first simplex
-\\ /common/property_types/Basic Types/Int ''l'' : the number of vertices of the second simplex
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Vector</common/property_types/Basic Types/Rational>
-  *      Gives a weight vector for the staircase triangulation of\\     the product of a //k-1//- and an //l-1//-dimensional simplex.
-  * //Example://\\ The following creates the staircase triangulation of the product of the 2- and the 1-simplex. \\ <code> >  $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 2 3 5}
- {0 1 3 5}
-</code>
-{{anchor:quotient_space_simplexity_lower_bound(Int d, Matrix V, Scalar volume, SparseMatrix cocircuit_equations):}} **''quotient_space_simplexity_lower_bound(Int d, Matrix V, Scalar volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''V'' : the input points or vertices
-\\ /polytope/functions/Triangulations, subdivisions and volume/quotient_space_simplexity_lower_bound/tparams/Scalar ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /common/property_types/Basic Types/Integer
-  *      Calculate a lower bound for the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold
-{{anchor:symmetrized_foldable_max_signature_upper_bound(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations):}} **''symmetrized_foldable_max_signature_upper_bound(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /common/property_types/Basic Types/Rational ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /common/property_types/Basic Types/Integer
-  *      Calculate the LP relaxation upper bound to the maximal signature of a foldable triangulation of polytope, point configuration or quotient manifold
-{{anchor:splits(Matrix V, Graph G, Matrix F, Int dimension):}} **''splits(Matrix V, Graph G, Matrix F, Int dimension)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''V'' : vertices of the polytope
-\\ /graph/objects/Combinatorics/Graph ''G'' : graph of the polytope
-\\ /common/property_types/Algebraic Types/Matrix ''F'' : facets of the polytope
-\\ /common/property_types/Basic Types/Int ''dimension'' : of the polytope
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Computes the [[/polytope/objects/Polytope/properties/Geometry/SPLITS|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.
-{{anchor:simplexity_ilp_with_angles(Int d, Matrix V, Matrix F, IncidenceMatrix VIF, IncidenceMatrix VIR, Int>> gens, Set> MIS, Scalar volume, SparseMatrix cocircuit_equations):}} **''simplexity_ilp_with_angles(Int d, Matrix V, Matrix F, IncidenceMatrix VIF, IncidenceMatrix VIR, Int>> gens, Set> MIS, Scalar volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''V'' : the input points or vertices
-\\ /common/property_types/Algebraic Types/Matrix ''F'' : the facets of the input polytope
-\\ /common/property_types/Set Types/IncidenceMatrix ''VIF'' : the vertices-in-facets incidence matrix
-\\ /common/property_types/Set Types/IncidenceMatrix ''VIR'' : the vertices-in-ridges incidence matrix
-\\ /common/property_types/Basic Types/Array</common/property_types/Basic Types/Array</common/property_types/Basic Types/Int>> ''gens'' : the generators of the symmetry group
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set> ''MIS'' : the (representative) maximal interior simplices
-\\ /polytope/functions/Triangulations, subdivisions and volume/simplexity_ilp_with_angles/tparams/Scalar ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /polytope/objects/Optimization/LinearProgram
-  *      Set up an ILP whose MINIMAL_VALUE is the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold
-{{anchor:delaunay_triangulation(VoronoiPolyhedron V):}} **''delaunay_triangulation(VoronoiPolyhedron V)''**
-  * //Parameters:
-/polytope/objects/VoronoiPolyhedron ''V'' : \\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>>
-  *      Compute the Delaunay triangulation of the given [[/polytope/objects/VoronoiPolyhedron/properties/SITES]] of a VoronoiPolyhedron //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).
-  * //Example://\\  \\ <code> >  $VD = new VoronoiPolyhedron(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;
- {0 1 3}
- {1 3 4}
- {1 2 4}
- {2 4 5}
-</code>
-{{anchor:common_refinement:}} **''common_refinement''**
-{{anchor:split_compatibility_graph(Matrix splits, Polytope P):}} **''split_compatibility_graph(Matrix splits, Polytope P)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''splits'' : the splits given by split equations
-\\ /polytope/objects/Polytope ''P'' : the input polytope
-\\
-  * //Returns:// /graph/objects/Combinatorics/Graph
-  *     DOC_FIXME: Incomprehensible description!\\     Computes the compatibility graph among the //splits// of a polytope //P//.
-{{anchor:coherency_index:}} **''coherency_index''**
-{{anchor:iterated_barycentric_subdivision(Cone c, Int n):}} **''iterated_barycentric_subdivision(Cone c, Int n)''**
-  * //Parameters:
-/polytope/objects/Cone ''c'' : input cone or polytope
-\\ /common/property_types/Basic Types/Int ''n'' : how many times to subdivide
-\\
-  * //Returns:// /topaz/objects/SimplicialComplex
-  *      Create a simplicial complex as an iterated barycentric subdivision of a given cone or polytope.
-{{anchor:n_triangulations(Matrix M, Bool optimization):}} **''n_triangulations(Matrix M, Bool optimization)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''M'' : in the plane (homogeneous coordinates)
-\\ /common/property_types/Basic Types/Bool ''optimization'' : defaults to 1, where 1 includes optimization and 0 excludes it
-\\
-  * //Returns:// /common/property_types/Basic Types/Integer
-  *      Calculates the number of triangulations of a planar point configuration. This can be space intensive.\\    \\     Victor Alvarez, Raimund Seidel:\\     A Simple Aggregative Algorithm for Counting Triangulations of Planar Point Sets and Related Problems.\\     In Proc. of the 29th Symposium on Computational Geometry (SoCG '13), pages 1-8, Rio de Janeiro, Brazil, 2013
-  * //Example://\\ To print the number of possible triangulations of a square, do this: \\ <code> >  print n_triangulations(cube(2)->VERTICES);
-</code>
-{{anchor:simplexity_ilp(Int d, Matrix points, Set> MIS, Scalar volume, SparseMatrix cocircuit_equations):}} **''simplexity_ilp(Int d, Matrix points, Set> MIS, Scalar volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set> ''MIS'' : the representatives of maximal interior simplices
-\\ /polytope/functions/Triangulations, subdivisions and volume/simplexity_ilp/tparams/Scalar ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /polytope/objects/Optimization/LinearProgram
-  *      Set up an ILP whose MINIMAL_VALUE is the minimal number of simplices needed to triangulate a polytope, point configuration or quotient manifold
-{{anchor:interior_and_boundary_ridges(Polytope P):}} **''interior_and_boundary_ridges(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : the input polytope or cone
-\\
-  * //Returns:// /common/property_types/Basic Types/Pair</common/property_types/Basic Types/Array</common/property_types/Set Types/Set>,/common/property_types/Basic Types/Array</common/property_types/Set Types/Set>>
-  *      Find the (//d//-1)-dimensional simplices in the interior and in the boundary of a //d//-dimensional polytope or cone
-  * //Example://\\  \\ <code> >  print interior_and_boundary_ridges(cube(2));
- <{0 3}
- {1 2}
- >
- <{0 1}
- {0 2}
- {1 3}
- {2 3}
- >
-</code>
-{{anchor:regularity_lp(Matrix points, Int> > subdiv):}} **''regularity_lp(Matrix points, Int> > subdiv)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : in homogeneous coordinates
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int> > ''subdiv'' : \\
-  * //Returns:// /polytope/objects/Polytope</polytope/functions/Triangulations, subdivisions and volume/regularity_lp/tparams/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//.
-{{anchor:placing_triangulation(Matrix Points):}} **''placing_triangulation(Matrix Points)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''Points'' : the given point set
-\\
-  * //Returns:// /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>>
-  *      Compute the placing triangulation of the given point set using the beneath-beyond algorithm.
-  * //Example://\\ To compute the placing triangulation of the square (of whose vertices we know that they're non-redundant), do this: \\ <code> >  $t = placing_triangulation(cube(2)->VERTICES, non_redundant=>1);
- print $t;
- {0 1 2}
- {1 2 3}
-</code>
-{{anchor:quotient_space_simplexity_ilp(Int d, Matrix V, Scalar volume, SparseMatrix cocircuit_equations):}} **''quotient_space_simplexity_ilp(Int d, Matrix V, Scalar volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''V'' : the input points or vertices
-\\ /polytope/functions/Triangulations, subdivisions and volume/quotient_space_simplexity_ilp/tparams/Scalar ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /polytope/objects/Optimization/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
-{{anchor:split_polyhedron(Polytope P):}} **''split_polyhedron(Polytope P)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P'' : \\
-  * //Returns:// /polytope/objects/Polytope
-  *      Computes the split polyhedron of a full-dimensional\\     polyhdron //P//.
-{{anchor:max_interior_simplices:}} **''max_interior_simplices''**
-{{anchor:foldable_max_signature_ilp(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations):}} **''foldable_max_signature_ilp(Int d, Matrix points, Rational volume, SparseMatrix cocircuit_equations)''**
-  * //Parameters:
-/common/property_types/Basic Types/Int ''d'' : the dimension of the input polytope, point configuration or quotient manifold
-\\ /common/property_types/Algebraic Types/Matrix ''points'' : the input points or vertices
-\\ /common/property_types/Basic Types/Rational ''volume'' : the volume of the convex hull
-\\ /common/property_types/Algebraic Types/SparseMatrix ''cocircuit_equations'' : the matrix of cocircuit equations
-\\
-  * //Returns:// /polytope/objects/Optimization/LinearProgram</common/property_types/Basic Types/Rational>
-  *      Set up an ILP whose MAXIMAL_VALUE is the maximal signature of a foldable triangulation of a polytope, point configuration or quotient manifold
-{{anchor:points2metric(Matrix points):}} **''points2metric(Matrix points)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : \\
-  * //Returns:// /common/property_types/Algebraic Types/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).
-  * //Example://\\  \\ <code> >  print points2metric(cube(2)->VERTICES, max=>1);
-2 2 2
-0 2 2
-2 0 2
-2 2 0
-</code>
-{{anchor:mixed_volume(Polytope P1, Polytope P2, Polytope Pn):}} **''mixed_volume(Polytope P1, Polytope P2, Polytope Pn)''**
-  * //Parameters:
-/polytope/objects/Polytope ''P1'' : first polytope
-\\ /polytope/objects/Polytope ''P2'' : second polytope
-\\ /polytope/objects/Polytope ''Pn'' : last polytope
-\\
-  * //Returns:// SCALAR
-  *      Produces the mixed volume of polytopes P<sub>1</sub>,P<sub>2</sub>,...,P<sub>n</sub>.
-  * //Example://\\  \\ <code> >  print mixed_volume(cube(2),simplex(2));
-</code>
-{{anchor:is_subdivision(Matrix points, Int>> faces):}} **''is_subdivision(Matrix points, Int>> faces)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''points'' : \\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>> ''faces'' : \\
-  *
-  * //Example://\\ Two potential subdivisions of the square without innter points: \\ <code> >  $points = cube(2)->VERTICES;
- print is_subdivision($points,[[0,1,3],[1,2,3]],interior_points=>[ ]);
- true
-</code>\\  \\ <code> >  print is_subdivision($points,[[0,1,2],[1,2]],interior_points=>[ ]);
- false
-</code>
-{{anchor:splits_in_subdivision(Matrix vertices, Int>> subdivision, Matrix splits):}} **''splits_in_subdivision(Matrix vertices, Int>> subdivision, Matrix splits)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''vertices'' : the vertices of the polyhedron
-\\ /common/property_types/Basic Types/Array</common/property_types/Set Types/Set</common/property_types/Basic Types/Int>> ''subdivision'' : a subdivision of the polyhedron
-\\ /common/property_types/Algebraic Types/Matrix ''splits'' : the splits of the polyhedron
-\\
-  * //Returns:// /common/property_types/Set Types/Set</common/property_types/Basic Types/Int>
-  *      Tests which of the //splits// of a polyhedron are coarsenings of the given //subdivision//.
-----
-==== Visualization ====
- These functions are for visualization.
-{{anchor:bounding_box(Matrix V, Scalar surplus_k, Bool voronoi):}} **''bounding_box(Matrix V, Scalar surplus_k, Bool voronoi)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''V'' : vertices that should be in the box
-\\ /polytope/functions/Visualization/bounding_box/tparams/Scalar ''surplus_k'' : size of the bounding box relative to the box spanned by //V//
-\\ /common/property_types/Basic Types/Bool ''voronoi'' : useful for visualizations of Voronoi diagrams that do not have enough vertices
-  default value is 0.
-\\
-  * //Returns:// /common/property_types/Algebraic Types/Matrix
-  *      Introduce artificial boundary facets (which are always vertical,\\     i.e., the last coordinate is zero) to allow for bounded images of \\     unbounded polyhedra (e.g. Voronoi polyhedra).\\     If the //voronoi// flag is set, the last direction is left unbounded.
-{{anchor:vlabels(Matrix vertices, Bool wo_zero):}} **''vlabels(Matrix vertices, Bool wo_zero)''**
-  * //Parameters:
-/common/property_types/Algebraic Types/Matrix ''vertices'' : the vertices of the polytope
-\\ /common/property_types/Basic Types/Bool ''wo_zero'' : includes (0) or omits (1) the entry at position 0
-\\
-  * //Returns:// ARRAY
-  *      Creates vertex labels for visualization from the //vertices// \\     of the polytope. The parameter //wo_zero// decides whether\\     the entry at position 0 (homogenizing coordinate) is omitted (1)\\     or included (0) in the label string."
-  * //Example://\\ This prints the vertex labels for the square with the origin as its center and  side length 2, where we omit the leading 1: \\ <code> >  $l = vlabels(cube(2)->VERTICES,1);
- print join(', ', @{$l});
- (-1,-1), (1,-1), (-1,1), (1,1)
-</code>