By far not every feature of `polymake`

system is developed by the `polymake`

project team itself. Instead, we purposely rely on the expertise of various research groups in the community. It is one of the main goals of our project to increase the interoperability of all the fascinating publicly available geometric software. And last but not least, having quite constrained man-power and time resources, it is obviously much easier to interface a well-tested, ready-to-use software package than to implement everything from scratch.

The external software used in `polymake`

can be divided in three categories:

The following libraries are mandatory prerequisites for polymake. You can't build nor use polymake without having installed both on your system.

GNU Multiple-Precision Library (GMP) (version 4.X up to 6.X)

A well-known implementation of integer, rational, and floating-point arithmetic (and beyond) with unlimited precision. It became a standard arithmetic engine in many geometric and algebraic software packages in the last years. polymake makes massive use of the GMP integers and rationals via own C++ wrapper classes.

GNU Multiple-Precision floating-point computations with correct Rounding (MPFR) (version 3.X)

Floating-point arithmetic with predictable and platform-independent results. Used in polymake since release 2.9 for some constructions requiring intermediate floating-point computations, like random sphere or regular n-gon.

The following are polymake extensions that are included in the main package and provide interfaces to important external software. Some are only bare interfaces, but others already include the corresponding library code.

** Note: ** The `-minimal`

archive of polymake excludes the bundled code but still has the interfaces for cdd, lrs and nauty. Furthermore, the bundled extensions for jreality is removed.

Due to license agreements and/or kind allowance of the authors, these libraries are packed together with the polymake distribution. You don't have to download and install them separately. We are keeping track of their further development and always include the most recent versions available at the moment of making the current polymake release.

`cdd`

: Convex hull computations

Provides an interface to cddlib (by Komei Fukuda, Institute for Operations Research, ETH Zürich).

**Note:**This interface can also work with an installed version instead of the bundled code.Contains the double description method (dual Fourier-Motzkin) for convex hull and vertex enumeration, as well as a dual simplex LP solver, both implemented for floating-point and unlimited precision rational numbers.

`lrs`

: Convex hull computations

Provides an interface to lrslib (by David Avis, McGill University).

**Note:**This interface can also work with an installed version instead of the bundled code.Contains the reverse search method of Avis and Fukuda, and a primal simplex LP solver, both using unlimited precision arithmetic.

`nauty`

: Computing of automorphism groups of graphs

Provides an interface to nauty (version 2.5r9)

by Brendan McKay, Australian National University.

**Note:**This interface can also work with a custom source directory instead of the bundled code, since 3.0r2.

Alternative: blissComputes automorphism groups of graphs.

`polymake`

uses it for checking combinatorial equivalence and congruence of polytopes as well as isomorphy of graphs.`group`

: Dealing with permutation groups

Provides interfaces to PermLib (by Thomas Rehn) and SymPol (by Thomas Rehn and Achill Schürmann).`libnormaliz`

: Computations with affine monoids.

Provides an interface to Normaliz (by Winfried Bruns, Bogdan Ichim and Christof Söger).Normaliz is a tool for computations in affine monoids, vector configurations, lattice polytopes, and rational cones. Since version 2.8 it comes with a very fast parallelized algorithm for lattice point enumeration.

`jreality`

: Provides an interface to jReality (by Charles Gunn, Tim Hoffmann, Markus Schmies, Steffen Weissmann et al., Geometry Group, TU Berlin).

Needs ant to be built.High-end visualization in 3D (experimental). Since polymake release 2.9.9, a stable snapshot of jReality source code is bundled with polymake. You don't need to download it separately unless you will try a most recent version of it.

`bliss`

: Computing of automorphism groups of graphs

Provides an interface to bliss (by Tommi Junttila and Petteri Kaski).

Requires headers to be installed in a subfolder`bliss`

in the include directory, as in the debian package.

Alternative: nauty`ppl`

: a modern C++ library for the manipulation of numerical information that can be represented by points in some n-dimensional vector space

Provides an interface to the Parma Polyhedra Library (by Roberto Bagnara et al)`singular`

: Working with Gröbner bases

Provides an interface to Singular (by Wolfram Decker, Gert-Martin Greuel, Gerhard Pfister, and Hans Schönemann).

Please check the installation details for the bundled extension`singular`

.`javaview`

: Provides an interface to JavaView (by Konrad Polthier, Felix Kälberer, Samy Khadem, Eike Preuss, Ulrich Reitebuch, Sonderforschungsbereich 288, TU Berlin).Visualizes 3D- and 4D-polytopes (and much more).

The following can be enabled or disabled in a running polymake session with `reconfigure “something.rules”;`

. Check the output of `show_unconfigured;`

for more help.

See also above for the interfaces to jReality and JavaView.

three.js

by Ricardo Cabello.three.js is a lightweight 3D library with a very low level of complexity. Provides 3D-visualization in a webbrowser.

SplitsTree

by David Bryant and Daniel Huson, Universität Tübingen.Visualization of phylogenetic trees.

geomview

Geometry Center, University of Minnesota.Visualizes 3D- and 4D-polytopes.

3D- and 4D-visualization by high-end ray-tracing.

Visualizes graphs and face lattices.

TOPCOM (version 0.16.0)

by Jörg Rambau, Universität Bayreuth.Explores triangulations of points configurations.

vinci (version 1.0.5)

by Benno Büeler, Andreas Enge, and Komei Fukuda.Computes the volume of polytopes using floating point arithmetic.

LattE

by Jesus De Loera and his co-authors.LattE is a software dedicated to the problems of counting and detecting lattice points inside convex polytopes, and the solution of integer programs. LattE contains the first ever implementation of Barvinok's algorithm. LattE stands for “Lattice point Enumeration”. We recommend to use LattE macchiato instead, the improved and enhanced version of LattE by Matthias Köppe.

LattE macchiato

by Matthias Köppe.LattE macchiato is an improved version of LattE, derived from the latest release 1.2. For full functionality either choose the version “LattE, for tea, too”, that also installs 4ti2 and other required packages or first install TOPCOM, NTL, LiDia, and 4ti2.

Normaliz

by Winfried Bruns, Bogdan Ichim and Christof Söger.Normaliz is a (command line) tool for computations in affine monoids, vector configurations, lattice polytopes, and rational cones. Since version 2.8 it comes with a very fast parallelized algorithm for lattice point enumeration.

barvinok

by Sven Verdoolaege.barvinok is a library for counting the number of integer points in parametrized and non-parametrized polytopes. For parametrized polytopes an explicit function in the shape of a piece-wise step-polynomial is constructed. This is a generalization of both Ehrhart quasi-polynomials and vector partition functions.

Rule files using barvinok for the computation of the number of lattice points and the coefficients of the Ehrhart polynomial are currently not part of the standard polymake distribution. They are available as a separate extension to polymake.

4ti2

by Ralf Hemmecke, Raymond Hemmecke, Matthias Köppe, Peter Malkin, and Matthias Walter.

Linux RPM availableA software package for algebraic, geometric and combinatorial problems on linear spaces.

PORTA (version 1.3.2)

by Thomas Christoph and Andreas Loebel, ZIB / Universität Heidelberg.An implementation of Fourier-Motzkin elimination. This program seems not to be further developed nor maintained any more; moreover, the limited precision arithmetic used in it makes it fail in ways hard to predict or analyze. This is why its use is heavily

**deprecated**. We offer an interface mostly for historical reasons.If you must use it nonetheless at the very least increase the length of the char arrays fname and outfname in porta.c, say from 20 to 255, in order to avoid some segfaults.

See also the function

`porta2poly`

for importing PORTA files into polymake.convex (version 1.1.1)

by Matthias Franz.Convex is a Maple package for convex geometry. It can deal with polytopes and, more generally, with all kinds of polyhedra of (in principle) arbitrary dimension. The only restriction is that all coordinates must be rational. polymake interface.

HAP (version 1.3)

by Graham Ellis.HAP is a homological algebra library for use with the GAP computer algebra system, and is still under development. Its initial focus is on computations related to the cohomology of groups. Both finite and infinite groups are handled, with main emphasis on integer coefficients. For polyhedral computations, HAP interfaces to polymake.

polymake interface in GAP

by Thomas Bächler and Sebastian Gutsche, see interfaces for more details.polymake interface in Singular

by Janko Böhm and Yu Ren, see interfaces for more details.azove (version 2.0)

by Markus Behle.

Linux RPM availableazove is a tool designed for counting (without explicit enumeration) and enumeration of 0/1 vertices. Given a polytope by a linear relaxation or facet description P = {x | Ax ⇐ b}, all 0/1 points lying in P can be counted or enumerated. This is done by intersecting the polytope P with the unit-hypercube [0,1]d. The integral vertices (no fractional ones) of this intersection will be enumerated. If P is a 0/1 polytope, azove solves the vertex enumeration problem.

*Note:*azove2 might not run on systems with a low percentage of free memory (change LEFTOVER_FREE_MEMORY in azove.cpp) and also under linux kernel ≥3.14 due to changes in`/proc/meminfo`

. This patch removes the dynamic memory allocation, forces a fixed number of signature nodes and thus works around the problems on recent kernel versions.

homology

by Frank Heckenbach and his co-authors.An efficient program computing homology groups of simplicial complexes.

The famous group-theoretical software package. Can be used to analyze the fundamental group of a simplicial complex.

You should download and install these packages on your own, provided you accept the license agreements. Don't merge them into the `polymake`

directory tree, as they might get overwritten by the next polymake upgrade.

For your convenience, the interface components for external software are kept in separate rulefiles. The auto-configuration routines defined there try to find the installed software (usually by examining your `PATH`

variable). In the case of a failure, the rulefile gets disabled until you install the lacking software package and repeat the configuration.

At any rate, we strongly recommend you to install some visualization software (preferably JavaView), as polymake were much more boring without all these colorful pictures.

Note: Version numbers given in the descriptions are not binding. These are the latest versions that we are aware of and proven to work with polymake. You are free to use other versions as long as the backward compatibility (API and/or interchange file format, whatever appropriate) is preserved.

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Noncommercial-Share Alike 4.0 International