33.1 Lattice and reflexive polytopes

Module: sage.geometry.lattice_polytope

Lattice and reflexive polytopes

This module provides tools for work with lattice and reflexive polytopes. A convex polytope is the convex hull of finitely many points in $\mathbf{R}^n$ . The dimension of a polytope is the smallest such that the polytope can be embedded in $\mathbf{R}^n$ .

A lattice polytope is a polytope whose vertices all have integer coordinates.

If is a lattice polytope, the dual polytope of is

$\displaystyle \{y \in \mathbf{Z}^n : x\cdot y \geq -1$ all $\displaystyle x \in L\}$

A reflexive polytope is a lattice polytope, such that its polar is also a lattice polytope, i.e. has vertices with integer coordinates.

This SAGE module uses Package for Analyzing Lattice Polytopes (PALP), which is a program written in C by Maximilian Kreuzer and Harald Skarke, which is freely available under the GNU licence terms at http://tph16.tuwien.ac.at/~kreuzer/CY/. Moreover, PALP is included standard with SAGE.

PALP is described in the paper math.SC/0204356. Its distribution also contains the application nef.x, which was created by Erwin Riegler and computes nef partitions and Hodge data for toric complete intersections.

ACKNOWLEDGMENT: polytope.py module written by William Stein was used as an example of organizing an interface between an external program and SAGE. William Stein also helped Andrey Novoseltsev with debugging and tuning of this module.

IMPORTANT NOTE: PALP requires some parameters to be determined during compilation time, i.e., the maximum dimension of polytopes, the maximum number of points, etc. These limitations may lead to errors during calls to different functions of these module. Currently, a ValueError exception will be raised if the output of poly.x or nef.x is empty or contains the exclamation mark. The error message will contain the exact command that caused an error, the description and vertices of the polytope, and the obtained output.

Data obtained from PALP and some other data is cached and most returned values are immutable. In particular, you cannot change the vertices of the polytope or their order after creation of the polytope.

If you are going to work with large sets of data, take a look at all_* functions in this module. They precompute different data for sequences of polynomials with a few runs of external programs. This can significantly affect the time of future computations. You can also use dump/load, but not all data will be stored (currently only faces and the number of their internal and boundary points are stored, in addition to polytope vertices and its polar).

Author Log:

Andrey Novoseltsev (2007-01-11): initial version of this module
Andrey Novoseltsev (2007-01-15: all_* functions
Maximilian Kreuzer and Harald Skarke: authors of PALP
Erwin Riegler: the author of nef.x

Module-level Functions

LatticePolytope( data, [desc=None], [compute_vertices=False], [copy_vertices=True], [n=0])

Construct a lattice polytope.

LatticePolytope(data, [desc], [compute_vertices], [copy_vertices], [n])

INPUT:
    data -- a matrix of \emph{MAXIMAL} rank, whose columns are vertices of
            the polytope (unless \code{compute_vertices} is True);
            a file with matrix data, open for reading;
            or a filename of such a file.
            See \code{read_palp_matrix} for the file format.
            Points of the given matrix must span the space.
    desc -- (default: "A lattice polytope") description of the polytope.
    compute_vertices -- (default: False) if True, the convex hull of
            the given points will be computed for determining vertices.
            Otherwise, the given points are vertices.
    copy_vertices -- (default: True) if False and \code{data} is a
            matrix of vertices, it will be made immutable.
    n -- (default: 0) if \code{data} is a name of a file, that contains
            data blocks for several polytopes, the n-th block will be used.
            \emph{NUMERATION STARTS WITH ZERO}.

OUTPUT:
    a lattice polytope

Here we construct a polytope from a matrix whose columns are vertices in 3-dimensional space. In the first case a copy of the given matrix is made during construction, in the second one the matrix is made immutable and used as a matrix of vertices.

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0],
...                   [0, 1, 0,  0, -1,  0],
...                   [0, 0, 1,  0,  0, -1]])
...
sage: p = LatticePolytope(m)
sage: p
A lattice polytope: 3-dimensional, 6 vertices.
sage: m.is_mutable()
True
sage: m is p.vertices()
False
sage: p = LatticePolytope(m, copy_vertices=False)
sage: m.is_mutable()
False
sage: m is p.vertices()
True

We draw a pretty picture of the polytype in 3-dimensional space:

sage: p.plot().show()

Now we add an extra point to the matrix...

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0, 0],
...                   [0, 1, 0,  0, -1,  0, 0],
...                   [0, 0, 1,  0,  0, -1, 0]])
...
sage: p = LatticePolytope(m, "A lattice polytope with WRONG vertices")
sage: p
A lattice polytope with WRONG vertices: 3-dimensional, 7 vertices.

The above construction is WRONG since the origin is an interior point of the octahedron. If you don't know in advance that your data are vertices of the polytope, use compute_vertices option as below:

sage: p = LatticePolytope(m, "A lattice polytope constructed from 7 points",
...                         compute_vertices=True)
...
sage: p
A lattice polytope constructed from 7 points: 3-dimensional, 6 vertices.

Points of the given matrix must always span the space, this conditions will be checked only if you specify compute_vertices option:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m, compute_vertices=True)
Traceback (most recent call last):
...
ValueError: Points must span the space!

all_cached_data( polytopes)

all_faces( polytopes)

all_nef_partitions( polytopes, [keep_symmetric=False])

all_points( polytopes)

all_polars( polytopes)

filter_polytopes( f, polytopes, [subseq=None], [print_numbers=False])

octahedron( dim)

positive_integer_relations( points)

projective_space( dim)

read_all_polytopes( file_name, [desc=None])

read_palp_matrix( data)

sage_matrix_to_maxima( m)

Convert a SAGE matrix to the string representation of Maxima.

skip_palp_matrix( data, [n=1])

write_palp_matrix( m, [ofile=None], [comment=], [format=None])

Class: _PolytopeFace

class _PolytopeFace
_PolytopeFace(polytope, vertices, facets)

Construct a polytope face.

POLYTOPE FACES SHOULD NOT BE CONSTRUCTED OUTSIDE OF LATTICE POLYTOPES!

INPUT: polytope - a polytope whose face is being constructed. vertices - a sequence of indices of generating vertices. facets - a sequence of indices of facets containing this face.

_PolytopeFace( self, polytope, vertices, facets)

Construct a face.

Functions: boundary_points, facets, interior_points, nboundary_points, nfacets, ninterior_points, npoints, nvertices, points, vertices

boundary_points( self)

facets( self)

interior_points( self)

nboundary_points( self)

nfacets( self)

ninterior_points( self)

npoints( self)

nvertices( self)

points( self)

vertices( self)

Special Functions: __reduce__, _repr_

__reduce__( self)

Reduction function. Does not store data that can be relatively fast recomputed.

_repr_( self)

Return a string representation of this face.

Class: LatticePolytopeClass

class LatticePolytopeClass: Class of lattice/reflexive polytopes.
Use LatticePolytope for constructing a polytope.

LatticePolytopeClass( self, data, desc, compute_vertices, [copy_vertices=True], [n=0])

Construct a lattice polytope. See LatticePolytope.

Functions: dim, distances, faces, facets, is_reflexive, mif, nef_partitions, nef_x, nfacets, npoints, nvertices, parent, plot, points, polar, poly_x, show, vertices

dim( self)

distances( self)

faces( self, [dim=None], [codim=None])

facets( self)

is_reflexive( self)

mif( self, partition)

nef_partitions( self, [keep_symmetric=False])

nef_x( self, keys)

nfacets( self)

npoints( self)

nvertices( self)

parent( self)

plot( self, [camera_center=None])

points( self)

polar( self)

poly_x( self, keys)

show( self, [camera_center=None])

vertices( self)

Special Functions: __reduce__, __setstate__, _compute_faces, _face_compute_points, _face_split_points, _palp, _read_equations, _read_faces, _read_nef_partitions, _repr_

__reduce__( self)

Reduction function. Does not store data that can be relatively fast recomputed.

__setstate__( self, state)

Restores the state of pickled polytope.

_compute_faces( self)

_face_compute_points( self, face)

Compute lattice points of face.

_face_split_points( self, face)

Compute boundary and interior lattice points of face.

_palp( self, command)

_read_equations( self, data)

Read equations of facets/vertices of polar polytope from string or file.

_read_faces( self, data)

Read faces informations from string or file.

_read_nef_partitions( self, data)

Read NEF-partitions from string or file.

_repr_( self)

Return a string representation of this polytope.

Class: NEFPartition

class NEFPartition
Construct a NEF-partition from the given list.

A NEF-partition with parts, $V = V_0 \cap V_1 \cap \dots \cap V_{k-1}$ , is represented by a single list of lenght $n = \char93 V$ , in which the -th entry is the part number of the -th vertex of a polytope.

NOTE THAT NUMERATON OF PARTS STARTS WITH ZERO.

All elements of the list will be coerced to integers, so it is OK to use either a list of numbers or a list of strings:

sage: lattice_polytope.NEFPartition([1, 1, 0, 0, 0, 1])
[1, 1, 0, 0, 0, 1]
sage: lattice_polytope.NEFPartition(['1', '1', '0', '0', '0', '1'])
[1, 1, 0, 0, 0, 1]

NEFPartition( self, data)

Construct a NEF-partition.

Functions: nparts, part, part_of_vertex

nparts( self)

part( self, i)

part_of_vertex( self, i)

Class: SetOfAllLatticePolytopesClass

class SetOfAllLatticePolytopesClass

Special Functions: __call__, _repr_

SAGE Reference Manual

Previous: 33. Combinatorial Geometry Up: 33. Combinatorial Geometry Next: 33.2 Groebner Fans

Release 2007.10.28, documentation updated on October 28, 2007.

See About this document... for information on suggesting changes.