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 $\RR^n$ . The dimension $n$ of a polytope is the smallest $n$ such that the polytope can be embedded in $\RR^n$ .

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

If $L$ is a lattice polytope, the dual polytope of $L$ is

$\{y \in \ZZ^n : x\cdot y \geq -1 \text{ all } x \in L\}$

A reflexive polytope is a lattice polytope, such that its polar is also a lattice polytope, i.e. it is bounded and 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 license 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.

Robert Bradshaw helped Andrey Novoseltsev to realize plot3d function.

Note

IMPORTANT: 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).

AUTHORS:

Andrey Novoseltsev (2007-01-11): initial version of this module
Andrey Novoseltsev (2007-01-15): all_* functions
Andrey Novoseltsev (2008-04-01): second version, including:
- dual NEF-partitions and necessary convex_hull and minkowski_sum
- built-in sequences of 2- and 3-dimensional reflexive polytopes
- plot3d, skeleton_show
Andrey Novoseltsev (2009-08-26): dropped maximal dimension requirement
Maximilian Kreuzer and Harald Skarke: authors of PALP (which was also used to obtain the list of 3-dimensional reflexive polytopes)
Erwin Riegler: the author of nef.x

sage.geometry.lattice_polytope.LatticePolytope(data, desc=None, compute_vertices=True, copy_vertices=True, n=0)¶

Construct a lattice polytope.

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

INPUT:

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

OUTPUT: a lattice polytope

EXAMPLES: 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, compute_vertices=False, 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.plot3d().show()

Now we add an extra point, which is in the interior of the polytope...

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 constructed from 7 points")
sage: p
A lattice polytope constructed from 7 points: 3-dimensional, 6 vertices.

You can suppress vertex computation for speed but this can lead to mistakes:

sage: p = LatticePolytope(m, "A lattice polytope with WRONG vertices",
...                         compute_vertices=False)
...
sage: p
A lattice polytope with WRONG vertices: 3-dimensional, 7 vertices.

Given points must be in the lattice:

sage: LatticePolytope(matrix([1/2, 3/2]))
...
ValueError: Points must be integral!
Given:
[1/2 3/2]

But it is OK to create polytopes of non-maximal dimension:

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0, 0],
...                   [0, 1, 0,  0, -1,  0, 0],
...                   [0, 0, 0,  0,  0,  0, 0]])
...
sage: p = LatticePolytope(m)
sage: p
A lattice polytope: 2-dimensional, 4 vertices.
sage: p.vertices()
[ 1  0 -1  0]
[ 0  1  0 -1]
[ 0  0  0  0]

class sage.geometry.lattice_polytope.LatticePolytopeClass(data, desc, compute_vertices, copy_vertices=True, n=0)¶

Bases: sage.structure.sage_object.SageObject

Class of lattice/reflexive polytopes.

Use LatticePolytope for constructing a polytope.

affine_transform(a=1, b=0)¶

Return a*P+b, where P is this lattice polytope.

Note

#. While a and b may be rational, the final result must be a lattice polytope, i.e. all vertices must be integral.

#. If the transform (restricted to this polytope) is bijective, facial structure will be preserved, e.g. the first facet of the image will be spanned by the images of vertices which span the first facet of the original polytope.

INPUT:

a - (default: 1) rational scalar or matrix
b - (default: 0) rational scalar or vector, scalars are interpreted as vectors with the same components

EXAMPLES:

sage: o = lattice_polytope.octahedron(2)
sage: o.vertices()
[ 1  0 -1  0]
[ 0  1  0 -1]
sage: o.affine_transform(2).vertices()
[ 2  0 -2  0]
[ 0  2  0 -2]
sage: o.affine_transform(1,1).vertices()
[2 1 0 1]
[1 2 1 0]
sage: o.affine_transform(b=1).vertices()
[2 1 0 1]
[1 2 1 0]
sage: o.affine_transform(b=(1, 0)).vertices()
[ 2  1  0  1]
[ 0  1  0 -1]
sage: a = matrix(QQ, 2, [1/2, 0, 0, 3/2])
sage: o.polar().vertices()
[-1  1 -1  1]
[ 1  1 -1 -1]
sage: o.polar().affine_transform(a, (1/2, -1/2)).vertices()
[ 0  1  0  1]
[ 1  1 -2 -2]

While you can use rational transformation, the result must be integer:

sage: o.affine_transform(a)
...
ValueError: Points must be integral!
Given:
[ 1/2    0 -1/2    0]
[   0  3/2    0 -3/2]

ambient_dim()¶

Return the dimension of the ambient space of this polytope.

EXAMPLES: We create a 3-dimensional octahedron and check its ambient dimension:

sage: o = lattice_polytope.octahedron(3)
sage: o.ambient_dim()
3

dim()¶

Return the dimension of this polytope.

EXAMPLES: We create a 3-dimensional octahedron and check its dimension:

sage: o = lattice_polytope.octahedron(3)
sage: o.dim()
3

Now we create a 2-dimensional diamond in a 3-dimensional space:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.dim()
2
sage: p.ambient_dim()
3

distances(point=None)¶

Return the matrix of distances for this polytope or distances for the given point.

The matrix of distances m gives distances m[i,j] between the i-th facet (which is also the i-th vertex of the polar polytope in the reflexive case) and j-th point of this polytope.

If point is specified, integral distances from the point to all facets of this polytope will be computed.

This function CAN be used for polytopes whose dimension is smaller than the dimension of the ambient space. In this case distances are computed in the affine subspace spanned by the polytope and if the point is given, it must be in this subspace.

EXAMPLES: The matrix of distances for a 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: o.distances()
[0 0 2 2 2 0 1]
[2 0 2 0 2 0 1]
[0 2 2 2 0 0 1]
[2 2 2 0 0 0 1]
[0 0 0 2 2 2 1]
[2 0 0 0 2 2 1]
[0 2 0 2 0 2 1]
[2 2 0 0 0 2 1]

Distances from facets to the point (1,2,3):

sage: o.distances([1,2,3])
(1, 3, 5, 7, -5, -3, -1, 1)

It is OK to use RATIONAL coordinates:

sage: o.distances([1,2,3/2])
(-1/2, 3/2, 7/2, 11/2, -7/2, -3/2, 1/2, 5/2)
sage: o.distances([1,2,sqrt(2)])
...
TypeError: unable to convert sqrt(2) to a rational

Now we create a non-spanning polytope:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.distances()
[0 2 2 0 1]
[2 2 0 0 1]
[0 0 2 2 1]
[2 0 0 2 1]
sage: p.distances((1/2, 3, 0))
(7/2, 9/2, -5/2, -3/2)
sage: p.distances((1, 1, 1))
...
ArithmeticError: vector is not in free module

edges()¶

Return the sequence of edges of this polytope (i.e. faces of dimension 1).

EXAMPLES: The octahedron has 12 edges:

sage: o = lattice_polytope.octahedron(3)
sage: len(o.edges())
12
sage: o.edges()
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]]

faces(dim=None, codim=None)¶

Return the sequence of proper faces of this polytope.

If dim or codim are specified, returns a sequence of faces of the corresponding dimension or codimension. Otherwise returns the sequence of such sequences for all dimensions.

EXAMPLES: All faces of the 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: o.faces()
[
[[0], [1], [2], [3], [4], [5]],
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]],
[[0, 1, 5], [1, 3, 5], [0, 4, 5], [3, 4, 5], [0, 1, 2], [1, 2, 3], [0, 2, 4], [2, 3, 4]]
]

Its faces of dimension one (i.e., edges):

sage: o.faces(dim=1)
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]]

Its faces of codimension two (also edges):

sage: o.faces(codim=2)
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]]

It is an error to specify both dimension and codimension at the same time, even if they do agree:

sage: o.faces(dim=1, codim=2)
...
ValueError: Both dim and codim are given!

The only faces of a zero-dimensional polytope are the empty set and the polytope itself, i.e. it has no proper faces at all:

sage: p = LatticePolytope(matrix([[1]]))
sage: p.vertices()
[1]
sage: p.faces()
[]

In particular, you an exception will be raised if you try to access faces of the given dimension or codimension, including edges and facets:

sage: p.facets()
...
IndexError: list index out of range

facet_constant(i)¶

Return the constant in the i-th facet inequality of this polytope.

The i-th facet inequality is given by self.facet_normal(i) * X + self.facet_constant(i) >= 0.

INPUT:

i - integer, the index of the facet

OUTPUT:

integer – the constant in the i-th facet inequality.

EXAMPLES:

Let’s take a look at facets of the octahedron and some polytopes inside it:

sage: o = lattice_polytope.octahedron(3)
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: o.facet_normal(0)
(-1, -1, 1)
sage: o.facet_constant(0)
1
sage: m = copy(o.vertices())
sage: m[0,0] = 0
sage: m
[ 0  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: p = LatticePolytope(m)
sage: p.facet_normal(0)
(-1, 0, 0)
sage: p.facet_constant(0)
0
sage: m[0,3] = 0
sage: m
[ 0  0  0  0  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: p = LatticePolytope(m)
sage: p.facet_normal(0)
(0, -1, 1)
sage: p.facet_constant(0)
1        

facet_normal(i)¶

Return the inner normal to the i-th facet of this polytope.

If this polytope is not full-dimensional, facet normals will be parallel to the affine subspace spanned by this polytope.

INPUT:

i – integer, the index of the facet

OUTPUT:

vectors – the inner normal of the i-th facet

EXAMPLES:

Let’s take a look at facets of the octahedron and some polytopes inside it:

sage: o = lattice_polytope.octahedron(3)
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: o.facet_normal(0)
(-1, -1, 1)
sage: o.facet_constant(0)
1
sage: m = copy(o.vertices())
sage: m[0,0] = 0
sage: m
[ 0  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: p = LatticePolytope(m)
sage: p.facet_normal(0)
(-1, 0, 0)
sage: p.facet_constant(0)
0
sage: m[0,3] = 0
sage: m
[ 0  0  0  0  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: p = LatticePolytope(m)
sage: p.facet_normal(0)
(0, -1, 1)
sage: p.facet_constant(0)
1        

facets()¶

Return the sequence of facets of this polytope (i.e. faces of codimension 1).

EXAMPLES: All facets of the 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: o.facets()
[[0, 1, 5], [1, 3, 5], [0, 4, 5], [3, 4, 5], [0, 1, 2], [1, 2, 3], [0, 2, 4], [2, 3, 4]]

Facets are the same as faces of codimension one:

sage: o.facets() is o.faces(codim=1)
True

index()¶

Return the index of this polytope in the internal database of 2- or 3-dimensional reflexive polytopes. Databases are stored in the directory of the package.

Note

The first call to this function for each dimension can take a few seconds while the dictionary of all polytopes is constructed, but after that it is cached and fast.

Return type:	integer

EXAMPLES: We check what is the index of the “diamond” in the database:

sage: o = lattice_polytope.octahedron(2)
sage: o.index()
3

Note that polytopes with the same index are not necessarily the same:

sage: o.vertices()
[ 1  0 -1  0]
[ 0  1  0 -1]
sage: lattice_polytope.ReflexivePolytope(2,3).vertices()
[ 1  0  0 -1]
[ 0  1 -1  0]

But they are in the same $GL(Z^n)$ orbit and have the same normal form:

sage: o.normal_form()
[ 1  0  0 -1]
[ 0  1 -1  0]
sage: lattice_polytope.ReflexivePolytope(2,3).normal_form()
[ 1  0  0 -1]
[ 0  1 -1  0]

is_reflexive()¶

Return True if this polytope is reflexive.

EXAMPLES: The 3-dimensional octahedron is reflexive (and 4318 other 3-polytopes):

sage: o = lattice_polytope.octahedron(3)
sage: o.is_reflexive()
True

But not all polytopes are reflexive:

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0],
...                   [0, 1, 0,  0, -1,  0],
...                   [0, 0, 0,  0,  0, -1]])
...
sage: p = LatticePolytope(m)
sage: p.is_reflexive()
False

Only full-dimensional polytopes can be reflexive (otherwise the polar set is not a polytope at all, since it is unbounded):

sage: m = matrix(ZZ, [[0, 1, 0, -1,  0],
...                   [0, 0, 1,  0, -1],
...                   [0, 0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.is_reflexive()
False

mif(partition)¶

Return all vectors $m_{i,f}$ , grouped into matrices.

INPUT:

partition - NEF-partition (instance of class NEFPartition)

OUTPUT: A sequence of matrices, one for each facet f of this polytope. Each row of each matrix corresponds to a part of the NEF-partition.

EXAMPLES: We compute $m_{i,f}$ matrices for one of the nef-partitions of the 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: nefp = o.nef_partitions()[0]
sage: o.mif(nefp)
[
[ 0  0  1]  [ 0  0  1]  [ 0  1  1]  [0 1 1]  [ 0  0 -1]  [ 0  0 -1]
[-1 -1  0], [ 1 -1  0], [-1  0  0], [1 0 0], [-1 -1  0], [ 1 -1  0],
<BLANKLINE>
[ 0  1 -1]  [ 0  1 -1]
[-1  0  0], [ 1  0  0]
]

nef_partitions(keep_symmetric=False, keep_products=True, keep_projections=True, hodge_numbers=False)¶

Return the sequence of NEF-partitions for this polytope.

INPUT:

keep_symmetric - (default: False) if True, “-s” option will be passed to nef.x in order to keep symmetric partitions;
keep_products - (default: True) if True, “-D” option will be passed to nef.x in order to keep product partitions;
keep_projections - (default: True) if True, “-P” option will be passed to nef.x in order to keep projection partitions;
hodge_numbers - (default: False) if False, “-p” option will be passed to nef.x in order to skip Hodge numbers computation, which takes a lot of time.

EXAMPLES: NEF-partitions of the 4-dimensional octahedron:

sage: o = lattice_polytope.octahedron(4)
sage: o.nef_partitions()
[
[1, 1, 0, 0, 1, 1, 0, 0] (direct product),
[1, 1, 1, 0, 1, 0, 0, 0],
[1, 1, 1, 0, 1, 1, 0, 0],
[1, 1, 1, 0, 1, 1, 1, 0] (direct product),
[1, 1, 1, 1, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 0] (projection)
]

Now we omit projections:

sage: o.nef_partitions(keep_projections=False)
[
[1, 1, 0, 0, 1, 1, 0, 0] (direct product),
[1, 1, 1, 0, 1, 0, 0, 0],
[1, 1, 1, 0, 1, 1, 0, 0],
[1, 1, 1, 0, 1, 1, 1, 0] (direct product),
[1, 1, 1, 1, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0]
]

At present, Hodge numbers cannot be computed for a given NEF-partition:

sage: o.nef_partitions()[1].hodge_numbers()
...
NotImplementedError: use nef_partitions(hodge_numbers=True)!

But they can be obtained from nef.x for all partitions at once. Partitions will be exactly the same:

sage: o.nef_partitions(hodge_numbers=True)
[
[1, 1, 0, 0, 1, 1, 0, 0] (direct product),
[1, 1, 1, 0, 1, 0, 0, 0],
[1, 1, 1, 0, 1, 1, 0, 0],
[1, 1, 1, 0, 1, 1, 1, 0] (direct product),
[1, 1, 1, 1, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 1, 1, 0] (projection)
]

Now it is possible to get Hodge numbers:

sage: o.nef_partitions(hodge_numbers=True)[1].hodge_numbers()
[20]

Since NEF-partitions are cached, Hodge numbers are accessible after the first request, even if you do not specify hodge_numbers anymore:

sage: o.nef_partitions()[1].hodge_numbers()
[20]

We illustrate removal of symmetric partitions on a diamond:

sage: o = lattice_polytope.octahedron(2)
sage: o.nef_partitions()
[
[1, 0, 1, 0] (direct product),
[1, 1, 0, 0],
[1, 1, 1, 0] (projection)
]
sage: o.nef_partitions(keep_symmetric=True)
[
[1, 1, 0, 1] (projection),
[1, 0, 1, 1] (projection),
[1, 0, 0, 1],
[0, 1, 1, 1] (projection),
[0, 1, 0, 1] (direct product),
[0, 0, 1, 1],
[1, 1, 1, 0] (projection)
]

NEF-partitions can be computed only for reflexive polytopes:

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0],
...                   [0, 1, 0,  0, -1,  0],
...                   [0, 0, 2,  0,  0, -1]])
...
sage: p = LatticePolytope(m)
sage: p.nef_partitions()
...
ValueError: The given polytope is not reflexive!
Polytope: A lattice polytope: 3-dimensional, 6 vertices.

nef_x(keys)¶

Run nef.x with given keys on vertices of this polytope.

INPUT:

keys - a string of options passed to nef.x. The key “-f” is added automatically.

OUTPUT: the output of nef.x as a string.

EXAMPLES: This call is used internally for computing NEF-partitions:

sage: o = lattice_polytope.octahedron(3)
sage: s = o.nef_x("-N -V -p")
sage: s                      # output contains random time
M:27 8 N:7 6  codim=2 #part=5
3 6  Vertices of P:
    1    0    0   -1    0    0
    0    1    0    0   -1    0
    0    0    1    0    0   -1
 P:0 V:2 4 5       0sec  0cpu
 P:2 V:3 4 5       0sec  0cpu
 P:3 V:4 5       0sec  0cpu
np=3 d:1 p:1    0sec     0cpu

nfacets()¶

Return the number of facets of this polytope.

EXAMPLES: The number of facets of the 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: o.nfacets()
8

The number of facets of an interval is 2:

sage: LatticePolytope(matrix([1,2])).nfacets()
2

Now consider a 2-dimensional diamond in a 3-dimensional space:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.nfacets()
4

normal_form()¶

Return the normal form of vertices of the polytope.

Two full-dimensional lattice polytopes are in the same GL(Z)-orbit if and only if their normal forms are the same. Normal form is not defined and thus cannot be used for polytopes whose dimension is smaller than the dimension of the ambient space.

EXAMPLES: We compute the normal form of the “diamond”:

sage: o = lattice_polytope.octahedron(2)
sage: o.vertices()
[ 1  0 -1  0]
[ 0  1  0 -1]
sage: o.normal_form()
[ 1  0  0 -1]
[ 0  1 -1  0]

The diamond is the 3rd polytope in the internal database...

sage: o.index()
3
sage: lattice_polytope.ReflexivePolytope(2,3).vertices()
[ 1  0  0 -1]
[ 0  1 -1  0]

It is not possible to compute normal forms for polytopes which do not span the space:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.normal_form()        
...
ValueError: Normal form is not defined for a 2-dimensional polytope in a 3-dimensional space!

npoints()¶

Return the number of lattice points of this polytope.

EXAMPLES: The number of lattice points of the 3-dimensional octahedron and its polar cube:

sage: o = lattice_polytope.octahedron(3)
sage: o.npoints()
7
sage: cube = o.polar()
sage: cube.npoints()
27

nvertices()¶

Return the number of vertices of this polytope.

EXAMPLES: The number of vertices of the 3-dimensional octahedron and its polar cube:

sage: o = lattice_polytope.octahedron(3)
sage: o.nvertices()
6
sage: cube = o.polar()
sage: cube.nvertices()
8

origin()¶

Return the index of the origin in the list of points of self.

OUTPUT:

integer if the origin belongs to this polytope, None otherwise.

EXAMPLES:

sage: o = lattice_polytope.octahedron(2)
sage: o.origin()
4
sage: o.point(o.origin())
(0, 0)

sage: p = LatticePolytope(matrix([[1,2]]))
sage: p.points()
[1 2]
sage: print p.origin()
None

parent()¶

Return the set of all lattice polytopes.

EXAMPLES:

sage: o = lattice_polytope.octahedron(3)
sage: o.parent()
Set of all Lattice Polytopes

plot3d(show_facets=True, facet_opacity=0.5, facet_color=(0, 1, 0), facet_colors=None, show_edges=True, edge_thickness=3, edge_color=(0.5, 0.5, 0.5), show_vertices=True, vertex_size=10, vertex_color=(1, 0, 0), show_points=True, point_size=10, point_color=(0, 0, 1), show_vindices=None, vindex_color=(0, 0, 0), vlabels=None, show_pindices=None, pindex_color=(0, 0, 0), index_shift=1.1000000000000001)¶

Return a 3d-plot of this polytope.

Polytopes with ambient dimension 1 and 2 will be plotted along x-axis or in xy-plane respectively. Polytopes of dimension 3 and less with ambient dimension 4 and greater will be plotted in some basis of the spanned space.

By default, everything is shown with more or less pretty combination of size and color parameters.

INPUT: Most of the parameters are self-explanatory:

show_facets - (default:True)
facet_opacity - (default:0.5)
facet_color - (default:(0,1,0))
facet_colors - (default:None) if specified, must be a list of colors for each facet separately, used instead of facet_color
show_edges - (default:True) whether to draw edges as lines
edge_thickness - (default:3)
edge_color - (default:(0.5,0.5,0.5))
show_vertices - (default:True) whether to draw vertices as balls
vertex_size - (default:10)
vertex_color - (default:(1,0,0))
show_points - (default:True) whether to draw other poits as balls
point_size - (default:10)
point_color - (default:(0,0,1))
show_vindices - (default:same as show_vertices) whether to show indices of vertices
vindex_color - (default:(0,0,0)) color for vertex labels
vlabels - (default:None) if specified, must be a list of labels for each vertex, default labels are vertex indicies
show_pindices - (default:same as show_points) whether to show indices of other points
pindex_color - (default:(0,0,0)) color for point labels
index_shift - (default:1.1)) if 1, labels are placed exactly at the corresponding points. Otherwise the label position is computed as a multiple of the point position vector.

EXAMPLES: The default plot of a cube:

sage: c = lattice_polytope.octahedron(3).polar()
sage: c.plot3d()

Plot without facets and points, shown without the frame:

sage: c.plot3d(show_facets=false,show_points=false).show(frame=False)

Plot with facets of different colors:

sage: c.plot3d(facet_colors=sage.plot.plot.rainbow(c.nfacets(), 'rgbtuple'))

It is also possible to plot lower dimensional polytops in 3D (let’s also change labels of vertices):

sage: lattice_polytope.octahedron(2).plot3d(vlabels=["A", "B", "C", "D"])

TESTS:

sage: m = matrix([[0,0,0],[0,1,1],[1,0,1],[1,1,0]]).transpose()
sage: p = LatticePolytope(m, compute_vertices=True)
sage: p.plot3d()

point(i)¶

Return the i-th point of this polytope, i.e. the i-th column of the matrix returned by points().

EXAMPLES: First few points are actually vertices:

sage: o = lattice_polytope.octahedron(3)
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: o.point(1)
(0, 1, 0)

The only other point in the octahedron is the origin:

sage: o.point(6)
(0, 0, 0)
sage: o.points()
[ 1  0  0 -1  0  0  0]
[ 0  1  0  0 -1  0  0]
[ 0  0  1  0  0 -1  0]

points()¶

Return all lattice points of this polytope as columns of a matrix.

EXAMPLES: The lattice points of the 3-dimensional octahedron and its polar cube:

sage: o = lattice_polytope.octahedron(3)
sage: o.points()
[ 1  0  0 -1  0  0  0]
[ 0  1  0  0 -1  0  0]
[ 0  0  1  0  0 -1  0]
sage: cube = o.polar()
sage: cube.points()
[-1  1 -1  1 -1  1 -1  1 -1 -1 -1 -1 -1  0  0  0  0  0  0  0  0  0  1  1  1  1  1]
[-1 -1  1  1 -1 -1  1  1 -1  0  0  0  1 -1 -1 -1  0  0  0  1  1  1 -1  0  0  0  1]
[ 1  1  1  1 -1 -1 -1 -1  0 -1  0  1  0 -1  0  1 -1  0  1 -1  0  1  0 -1  0  1  0]

Lattice points of a 2-dimensional diamond in a 3-dimensional space:

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.points()
[ 1  0 -1  0  0]
[ 0  1  0 -1  0]
[ 0  0  0  0  0]

We check that points of a zero-dimensional polytope can be computed:

sage: p = LatticePolytope(matrix([[1]]))
sage: p.vertices()
[1]
sage: p.points()
[1]

polar()¶

Return the polar polytope, if this polytope is reflexive.

EXAMPLES: The polar polytope to the 3-dimensional octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: cube = o.polar()
sage: cube
A polytope polar to An octahedron: 3-dimensional, 8 vertices.

The polar polytope “remembers” the original one:

sage: cube.polar()
An octahedron: 3-dimensional, 6 vertices.
sage: cube.polar().polar() is cube
True

Only reflexive polytopes have polars:

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0],
...                   [0, 1, 0,  0, -1,  0],
...                   [0, 0, 2,  0,  0, -1]])
...
sage: p = LatticePolytope(m)
sage: p.polar()
...
ValueError: The given polytope is not reflexive!
Polytope: A lattice polytope: 3-dimensional, 6 vertices.

poly_x(keys, reduce_dimension=False)¶

Run poly.x with given keys on vertices of this polytope.

INPUT:

keys - a string of options passed to poly.x. The key “f” is added automatically.
reduce_dimension - (default: False) if True and this polytope is not full-dimensional, poly.x will be called for the vertices of this polytope in some basis of the spanned affine space.

OUTPUT: the output of poly.x as a string.

EXAMPLES: This call is used for determining if a polytope is reflexive or not:

sage: o = lattice_polytope.octahedron(3)
sage: print o.poly_x("e")
8 3  Vertices of P-dual <-> Equations of P
  -1  -1   1
   1  -1   1
  -1   1   1
   1   1   1
  -1  -1  -1
   1  -1  -1
  -1   1  -1
   1   1  -1

Since PALP has limits on different parameters determined during compilation, the following code is likely to fail, unless you change default settings of PALP:

sage: BIGO = lattice_polytope.octahedron(7)
sage: BIGO
An octahedron: 7-dimensional, 14 vertices.
sage: BIGO.poly_x("e")      # possibly different output depending on your system
...
ValueError: Error executing "poly.x -fe" for the given polytope!
Polytope: An octahedron: 7-dimensional, 14 vertices.
Vertices:
[ 1  0  0  0  0  0  0 -1  0  0  0  0  0  0]
[ 0  1  0  0  0  0  0  0 -1  0  0  0  0  0]
[ 0  0  1  0  0  0  0  0  0 -1  0  0  0  0]
[ 0  0  0  1  0  0  0  0  0  0 -1  0  0  0]
[ 0  0  0  0  1  0  0  0  0  0  0 -1  0  0]
[ 0  0  0  0  0  1  0  0  0  0  0  0 -1  0]
[ 0  0  0  0  0  0  1  0  0  0  0  0  0 -1]
Output:
increase POLY_Dmax!

You cannot call poly.x for polytopes that don’t span the space (if you could, it would crush anyway):

sage: m = matrix(ZZ, [[1, 0, -1,  0],
...                   [0, 1,  0, -1],
...                   [0, 0,  0,  0]])
...
sage: p = LatticePolytope(m)
sage: p.poly_x("e")
...
ValueError: Cannot run PALP for a 2-dimensional polytope in a 3-dimensional space!

But if you know what you are doing, you can call it for the polytope in some basis of the spanned space:

sage: print p.poly_x("e", reduce_dimension=True)
4 2  Equations of P
  -1   1     0
   1   1     2
  -1  -1     0
   1  -1     2

show3d()¶

Show a 3d picture of the polytope with default settings and without axes or frame.

See self.plot3d? for more details.

EXAMPLES:

sage: o = lattice_polytope.octahedron(3)
sage: o.show3d()

skeleton()¶

Return the graph of the one-skeleton of this polytope.

EXAMPLES: We construct the one-skeleton graph for the “diamond”:

sage: o = lattice_polytope.octahedron(2)
sage: g = o.skeleton()
sage: g
Graph on 4 vertices
sage: g.edges()
[(0, 1, None), (0, 3, None), (1, 2, None), (2, 3, None)]

skeleton_points(k=1)¶

Return the increasing list of indices of lattice points in k-skeleton of the polytope (k is 1 by default).

EXAMPLES: We compute all skeleton points for the cube:

sage: o = lattice_polytope.octahedron(3)
sage: c = o.polar()
sage: c.skeleton_points()
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 19, 21, 22, 23, 25, 26]

The default was 1-skeleton:

sage: c.skeleton_points(k=1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 19, 21, 22, 23, 25, 26]

0-skeleton just lists all vertices:

sage: c.skeleton_points(k=0)
[0, 1, 2, 3, 4, 5, 6, 7]

2-skeleton lists all points except for the origin (point #17):

sage: c.skeleton_points(k=2)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26]

3-skeleton includes all points:

sage: c.skeleton_points(k=3)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

It is OK to compute higher dimensional skeletons - you will get the list of all points:

sage: c.skeleton_points(k=100)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]

skeleton_show(normal=None)¶

Show the graph of one-skeleton of this polytope. Works only for polytopes in a 3-dimensional space.

INPUT:

normal - a 3-dimensional vector (can be given as a list), which should be perpendicular to the screen. If not given, will be selected randomly (new each time and it may be far from “nice”).

EXAMPLES: Show a pretty picture of the octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: o.skeleton_show([1,2,4])

Does not work for a diamond at the moment:

sage: o = lattice_polytope.octahedron(2)
sage: o.skeleton_show()
...
ValueError: need a polytope in a 3-dimensional space! Got:
An octahedron: 2-dimensional, 4 vertices.

traverse_boundary()¶

Return a list of indices of vertices of a 2-dimensional polytope in their boundary order.

Needed for plot3d function of polytopes.

EXAMPLES:

sage: c = lattice_polytope.octahedron(2).polar() sage: c.traverse_boundary() [0, 1, 3, 2]

vertex(i)¶

Return the i-th vertex of this polytope, i.e. the i-th column of the matrix returned by vertices().

EXAMPLES: Note that numeration starts with zero:

sage: o = lattice_polytope.octahedron(3)
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: o.vertex(3)
(-1, 0, 0)

vertices()¶

Return vertices of this polytope as columns of a matrix.

EXAMPLES: The lattice points of the 3-dimensional octahedron and its polar cube:

sage: o = lattice_polytope.octahedron(3)
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: cube = o.polar()
sage: cube.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]

class sage.geometry.lattice_polytope.NEFPartition(data, polytope=None)¶

Bases: sage.structure.sequence.Sequence

Construct a NEF-partition from the given list. If the second argument is given, it must be the polytope of the NEF-partition.

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

EXAMPLES: 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]

dual()¶

Compute dual nef-partition.

Computation follows the article “Combinatorial aspects of mirror symmetry” by V.Batyrev and B.Nill, initial polytope corresponds to Nabla*, output to Delta*.

EXAMPLES: We compute the dual nef-partition for the first nef-partition of the octahedron:

sage: o = lattice_polytope.octahedron(3)
sage: np = o.nef_partitions()[0]
sage: np
[1, 1, 0, 1, 0, 0]
sage: npd = np.dual()
sage: npd
[1, 0, 1, 0, 0, 1, 0, 1]
sage: npd.polytope().vertices()
[ 1  0  1  0  0 -1  0 -1]
[-1  1  0  0  0 -1  1  0]
[ 0  1  0  1 -1  0 -1  0]

hodge_numbers()¶

Return Hodge numbers corresponding to the given nef-partition.

Note

In order to use this function you must use nef_partitions(hodge_numbers=True) for computing nef-partitions.

EXAMPLE: Currently, you need to request hodge_numbers when you compute nef-partitions. (The following weird construction ensures that there are no cached numbers.)

sage: o = LatticePolytope(lattice_polytope.octahedron(4).vertices())
sage: np = o.nef_partitions()[0]
sage: np.hodge_numbers()
...
NotImplementedError: use nef_partitions(hodge_numbers=True)!
sage: np = o.nef_partitions(hodge_numbers=True)[0]
sage: np.hodge_numbers()
[4]

nparts()¶

Return the number of parts of this partitions.

EXAMPLES:

sage: nefp = lattice_polytope.NEFPartition([1, 1, 0, 0, 0, 1])
sage: nefp.nparts()
2

part(i)¶

Return the i-th part of the partition.

NUMERATON OF PARTS STARTS WITH ZERO.

EXAMPLES:

sage: nefp = lattice_polytope.NEFPartition([1, 1, 0, 0, 0, 1])
sage: nefp.part(0)
[2, 3, 4]
sage: nefp.part(1)
[0, 1, 5]

part_of_vertex(i)¶

Return the index of the part containing the i-vertex.

EXAMPLES: nefp.part_of_vertex(i) is equivalent to nefp[i].

sage: nefp = lattice_polytope.NEFPartition([1, 1, 0, 0, 0, 1])
sage: nefp.part_of_vertex(3)
0
sage: nefp.part_of_vertex(5)
1
sage: nefp[3]
0
sage: nefp[5]
1

You cannot change a NEF-partition once it is constructed:

sage: nefp[3] = 1
...
ValueError: object is immutable; please change a copy instead.

polytope()¶

Return the polytope of this NEF-partition.

EXAMPLE:

sage: o = lattice_polytope.octahedron(3)
sage: np = o.nef_partitions()[0]
sage: np.polytope() == o
True

sage.geometry.lattice_polytope.ReflexivePolytope(dim, n)¶

Return n-th reflexive polytope from the database of 2- or 3-dimensional reflexive polytopes.

Note

Numeration starts with zero: $0 \leq n \leq 15$ for ${\rm dim} = 2$ and $0 \leq n \leq 4318$ for ${\rm dim} = 3$ .
During the first call, all reflexive polytopes of requested dimension are loaded and cached for future use, so the first call for 3-dimensional polytopes can take several seconds, but all consecutive calls are fast.
Equivalent to ReflexivePolytopes(dim)[n] but checks bounds first.

EXAMPLES: The 3rd 2-dimensional polytope is “the diamond:”

sage: ReflexivePolytope(2,3)
Reflexive polytope    3: 2-dimensional, 4 vertices.
sage: lattice_polytope.ReflexivePolytope(2,3).vertices()
[ 1  0  0 -1]
[ 0  1 -1  0]

There are 16 reflexive polygons and numeration starts with 0:

sage: ReflexivePolytope(2,16)
...
ValueError: there are only 16 reflexive polygons!

It is not possible to load a 4-dimensional polytope in this way:

sage: ReflexivePolytope(4,16)
...
NotImplementedError: only 2- and 3-dimensional reflexive polytopes are available!

sage.geometry.lattice_polytope.ReflexivePolytopes(dim)¶

Return the sequence of all 2- or 3-dimensional reflexive polytopes.

Note

During the first call the database is loaded and cached for future use, so repetitive calls will return the same object in memory.

Parameter:	dim (2 or 3) – dimension of required reflexive polytopes
Return type:	list of lattice polytopes

EXAMPLES: There are 16 reflexive polygons:

sage: len(ReflexivePolytopes(2))
16

It is not possible to load 4-dimensional polytopes in this way:

sage: ReflexivePolytopes(4)
...
NotImplementedError: only 2- and 3-dimensional reflexive polytopes are available!

class sage.geometry.lattice_polytope.SetOfAllLatticePolytopesClass¶: Bases: sage.structure.parent.Set_generic

sage.geometry.lattice_polytope.all_cached_data(polytopes)¶

Compute all cached data for all given polytopes and their polars.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data. None of the polytopes in the given sequence should be constructed as the polar polytope to another one.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_cached_data([o])
sage: o.faces()
[
[[0], [1], [2], [3], [4], [5]],
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]],
[[0, 1, 5], [1, 3, 5], [0, 4, 5], [3, 4, 5], [0, 1, 2], [1, 2, 3], [0, 2, 4], [2, 3, 4]]
]

However, you cannot use it for polytopes that are constructed as polar polytopes of others:

sage: lattice_polytope.all_cached_data([o.polar()])
...
ValueError: Cannot read face structure for a polytope constructed as polar, use _compute_faces!

sage.geometry.lattice_polytope.all_faces(polytopes)¶

Compute faces for all given polytopes.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_faces([o])
sage: o.faces()
[
[[0], [1], [2], [3], [4], [5]],
[[1, 5], [0, 5], [0, 1], [3, 5], [1, 3], [4, 5], [0, 4], [3, 4], [1, 2], [0, 2], [2, 3], [2, 4]],
[[0, 1, 5], [1, 3, 5], [0, 4, 5], [3, 4, 5], [0, 1, 2], [1, 2, 3], [0, 2, 4], [2, 3, 4]]
]

However, you cannot use it for polytopes that are constructed as polar polytopes of others:

sage: lattice_polytope.all_faces([o.polar()])
...
ValueError: Cannot read face structure for a polytope constructed as polar, use _compute_faces!

sage.geometry.lattice_polytope.all_facet_equations(polytopes)¶

Compute polar polytopes for all reflexive and equations of facets for all non-reflexive polytopes.

all_facet_equations and all_polars are synonyms.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_polars([o])
sage: o.polar()
A polytope polar to An octahedron: 3-dimensional, 8 vertices.

sage.geometry.lattice_polytope.all_nef_partitions(polytopes, keep_symmetric=False)¶

Compute NEF-partitions for all given polytopes.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data.

Note: member function is_reflexive will be called separately for each polytope. It is strictly recommended to call all_polars on the sequence of polytopes before using this function.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_nef_partitions([o])
sage: o.nef_partitions()
[
[1, 1, 0, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 0, 0]
]

You cannot use this function for non-reflexive polytopes:

sage: m = matrix(ZZ, [[1, 0, 0, -1,  0,  0],
...                   [0, 1, 0,  0, -1,  0],
...                   [0, 0, 2,  0,  0, -1]])
...
sage: p = LatticePolytope(m)
sage: lattice_polytope.all_nef_partitions([o, p])
...
ValueError: The given polytope is not reflexive!
Polytope: A lattice polytope: 3-dimensional, 6 vertices.

sage.geometry.lattice_polytope.all_points(polytopes)¶

Compute lattice points for all given polytopes.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_points([o])
sage: o.points()
[ 1  0  0 -1  0  0  0]
[ 0  1  0  0 -1  0  0]
[ 0  0  1  0  0 -1  0]

sage.geometry.lattice_polytope.all_polars(polytopes)¶

Compute polar polytopes for all reflexive and equations of facets for all non-reflexive polytopes.

all_facet_equations and all_polars are synonyms.

This functions does it MUCH faster than member functions of LatticePolytope during the first run. So it is recommended to use this functions if you work with big sets of data.

INPUT: a sequence of lattice polytopes.

EXAMPLES: This function has no output, it is just a fast way to work with long sequences of polytopes. Of course, you can use short sequences as well:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.all_polars([o])
sage: o.polar()
A polytope polar to An octahedron: 3-dimensional, 8 vertices.

sage.geometry.lattice_polytope.always_use_files(new_state=None)¶

Set or get the way of using PALP for lattice polytopes.

INPUT:

new_state - (default:None) if specified, must be True or False.

OUTPUT: The current state of using PALP. If True, files are used for all calls to PALP, otherwise pipes are used for single polytopes. While the latter may have some advantage in speed, the first method is more reliable when working with large outputs. The initial state is True.

EXAMPLES:

sage: lattice_polytope.always_use_files()
True
sage: p = LatticePolytope(matrix([1, 20]))
sage: p.npoints()
20

Now let’s use pipes instead of files:

sage: lattice_polytope.always_use_files(False)
False
sage: p = LatticePolytope(matrix([1, 20]))
sage: p.npoints()
20

sage.geometry.lattice_polytope.convex_hull(points)¶

Compute the convex hull of the given points.

Note

points might not span the space. Also, it fails for large numbers of vertices in dimensions 4 or greater

INPUT:

points - a list that can be converted into vectors of the same dimension over ZZ.

OUTPUT: list of vertices of the convex hull of the given points (as vectors).

EXAMPLES: Let’s compute the convex hull of several points on a line in the plane:

sage: lattice_polytope.convex_hull([[1,2],[3,4],[5,6],[7,8]])
[(1, 2), (7, 8)]

sage.geometry.lattice_polytope.filter_polytopes(f, polytopes, subseq=None, print_numbers=False)¶

Use the function f to filter polytopes in a list.

INPUT:

f - filtering function, it must take one argument, a lattice polytope, and return True or False.
polytopes - list of polytopes.
subseq - (default: None) list of integers. If it is specified, only polytopes with these numbers will be considered.
print_numbers - (default: False) if True, the number of the current polytope will be printed on the screen before calling f.

OUTPUT: a list of integers – numbers of polytopes in the given list, that satisfy the given condition (i.e. function f returns True) and are elements of subseq, if it is given.

EXAMPLES: Consider a sequence of octahedrons:

sage: polytopes = Sequence([lattice_polytope.octahedron(n) for n in range(2, 7)], cr=True)
sage: polytopes
[
An octahedron: 2-dimensional, 4 vertices.,
An octahedron: 3-dimensional, 6 vertices.,
An octahedron: 4-dimensional, 8 vertices.,
An octahedron: 5-dimensional, 10 vertices.,
An octahedron: 6-dimensional, 12 vertices.
]

This filters octahedrons of dimension at least 4:

sage: lattice_polytope.filter_polytopes(lambda p: p.dim() >= 4, polytopes)
[2, 3, 4]

For long tests you can see the current progress:

sage: lattice_polytope.filter_polytopes(lambda p: p.nvertices() >= 10, polytopes, print_numbers=True)
0
1
2
3
4
[3, 4]

Here we consider only some of the polytopes:

sage: lattice_polytope.filter_polytopes(lambda p: p.nvertices() >= 10, polytopes, [2, 3, 4], print_numbers=True)
2
3
4
[3, 4]

sage.geometry.lattice_polytope.integral_length(v)¶

Compute the integral length of a given rational vector.

INPUT:

v - any object which can be converted to a list of rationals

OUTPUT: Rational number r such that v = r u, where u is the primitive integral vector in the direction of v.

EXAMPLES:

sage: lattice_polytope.integral_length([1, 2, 4])
1
sage: lattice_polytope.integral_length([2, 2, 4])
2
sage: lattice_polytope.integral_length([2/3, 2, 4])
2/3

sage.geometry.lattice_polytope.minkowski_sum(points1, points2)¶

Compute the Minkowski sum of two convex polytopes.

Note

Polytopes might not be of maximal dimension.

INPUT:

points1, points2 - lists of objects that can be converted into vectors of the same dimension, treated as vertices of two polytopes.

OUTPUT: list of vertices of the Minkowski sum, given as vectors.

EXAMPLES: Let’s compute the Minkowski sum of two line segments:

sage: lattice_polytope.minkowski_sum([[1,0],[-1,0]],[[0,1],[0,-1]])
[(1, 1), (1, -1), (-1, 1), (-1, -1)]

sage.geometry.lattice_polytope.octahedron(dim)¶

Return an octahedron of the given dimension.

EXAMPLES: Here are 3- and 4-dimensional octahedrons:

sage: o = lattice_polytope.octahedron(3)
sage: o
An octahedron: 3-dimensional, 6 vertices.
sage: o.vertices()
[ 1  0  0 -1  0  0]
[ 0  1  0  0 -1  0]
[ 0  0  1  0  0 -1]
sage: o = lattice_polytope.octahedron(4)
sage: o
An octahedron: 4-dimensional, 8 vertices.
sage: o.vertices()
[ 1  0  0  0 -1  0  0  0]
[ 0  1  0  0  0 -1  0  0]
[ 0  0  1  0  0  0 -1  0]
[ 0  0  0  1  0  0  0 -1]

There exists only one octahedron of each dimension:

sage: o is lattice_polytope.octahedron(4)
True

sage.geometry.lattice_polytope.positive_integer_relations(points)¶

Return relations between given points.

INPUT:

points - lattice points given as columns of a matrix

OUTPUT: matrix of relations between given points with non-negative integer coefficients

EXAMPLES: This is a 3-dimensional reflexive polytope:

sage: m = matrix(ZZ,[[1, 0, -1, 0, -1],
...                  [0, 1, -1, 0,  0],
...                  [0, 0,  0, 1, -1]])
...
sage: p = LatticePolytope(m)
sage: p.points()
[ 1  0 -1  0 -1  0]
[ 0  1 -1  0  0  0]
[ 0  0  0  1 -1  0]

We can compute linear relations between its points in the following way:

sage: p.points().transpose().kernel().echelonized_basis_matrix()
[ 1  0  0  1  1  0]
[ 0  1  1 -1 -1  0]
[ 0  0  0  0  0  1]

However, the above relations may contain negative and rational numbers. This function transforms them in such a way, that all coefficients are non-negative integers:

sage: lattice_polytope.positive_integer_relations(p.points())
[1 0 0 1 1 0]
[1 1 1 0 0 0]
[0 0 0 0 0 1]
sage: lattice_polytope.positive_integer_relations(ReflexivePolytope(2,1).vertices())
[2 1 1]

sage.geometry.lattice_polytope.projective_space(dim)¶

Return a simplex of the given dimension, corresponding to $P_{dim}$ .

EXAMPLES: We construct 3- and 4-dimensional simplexes:

sage: p = lattice_polytope.projective_space(3)
sage: p
A simplex: 3-dimensional, 4 vertices.
sage: p.vertices()
[ 1  0  0 -1]
[ 0  1  0 -1]
[ 0  0  1 -1]
sage: p = lattice_polytope.projective_space(4)
sage: p
A simplex: 4-dimensional, 5 vertices.
sage: p.vertices()
[ 1  0  0  0 -1]
[ 0  1  0  0 -1]
[ 0  0  1  0 -1]
[ 0  0  0  1 -1]

sage.geometry.lattice_polytope.read_all_polytopes(file_name, desc=None)¶

Read all polytopes from the given file.

INPUT:

file_name - the name of a file with VERTICES of polytopes
desc - a string, that will be used for creating polytope descriptions. By default it will be set to ‘A lattice polytope #%d from “filename”’ + and will be used as desc % n where n is the number of the polytope in the file (STARTING WITH ZERO).

OUTPUT: a sequence of polytopes

EXAMPLES: We use poly.x to compute polar polytopes of 2- and 3-octahedrons and read them:

sage: o2 = lattice_polytope.octahedron(2)
sage: o3 = lattice_polytope.octahedron(3)
sage: result_name = lattice_polytope._palp("poly.x -fe", [o2, o3])
sage: f = open(result_name)
sage: f.readlines()
['4 2  Vertices of P-dual <-> Equations of P\n', '  -1   1\n', '   1   1\n', '  -1  -1\n', '   1  -1\n', '8 3  Vertices of P-dual <-> Equations of P\n', '  -1  -1   1\n', '   1  -1   1\n', '  -1   1   1\n', '   1   1   1\n', '  -1  -1  -1\n', '   1  -1  -1\n', '  -1   1  -1\n', '   1   1  -1\n']
sage: f.close()
sage: lattice_polytope.read_all_polytopes(result_name, desc="Polytope from file %d")
[
Polytope from file 0: 2-dimensional, 4 vertices.,
Polytope from file 1: 3-dimensional, 8 vertices.
]
sage: os.remove(result_name)

sage.geometry.lattice_polytope.read_palp_matrix(data)¶

Read and return an integer matrix from a string or an opened file.

First input line must start with two integers m and n, the number of rows and columns of the matrix. The rest of the first line is ignored. The next m lines must contain n numbers each.

If m>n, returns the transposed matrix. If the string is empty or EOF is reached, returns the empty matrix, constructed by matrix().

EXAMPLES:

sage: lattice_polytope.read_palp_matrix("2 3 comment \n 1 2 3 \n 4 5 6")
[1 2 3]
[4 5 6]
sage: lattice_polytope.read_palp_matrix("3 2 Will be transposed \n 1 2 \n 3 4 \n 5 6")
[1 3 5]
[2 4 6]

sage.geometry.lattice_polytope.sage_matrix_to_maxima(m)¶

Convert a Sage matrix to the string representation of Maxima.

EXAMPLE:

sage: m = matrix(ZZ,2)
sage: lattice_polytope.sage_matrix_to_maxima(m)
matrix([0,0],[0,0])

sage.geometry.lattice_polytope.skip_palp_matrix(data, n=1)¶

Skip matrix data in a file.

INPUT:

data - opened file with blocks of matrix data in the following format: A block consisting of m+1 lines has the number m as the first element of its first line.
n - (default: 1) integer, specifies how many blocks should be skipped

If EOF is reached during the process, raises ValueError exception.

EXAMPLE: We create a file with vertices of the square and the cube, but read only the second set:

sage: o2 = lattice_polytope.octahedron(2)
sage: o3 = lattice_polytope.octahedron(3)
sage: result_name = lattice_polytope._palp("poly.x -fe", [o2, o3])
sage: f = open(result_name)
sage: f.readlines()
['4 2  Vertices of P-dual <-> Equations of P\n', '  -1   1\n', '   1   1\n', '  -1  -1\n', '   1  -1\n', '8 3  Vertices of P-dual <-> Equations of P\n', '  -1  -1   1\n', '   1  -1   1\n', '  -1   1   1\n', '   1   1   1\n', '  -1  -1  -1\n', '   1  -1  -1\n', '  -1   1  -1\n', '   1   1  -1\n']
sage: f.close()
sage: f = open(result_name)
sage: lattice_polytope.skip_palp_matrix(f)
sage: lattice_polytope.read_palp_matrix(f)
[-1  1 -1  1 -1  1 -1  1]
[-1 -1  1  1 -1 -1  1  1]
[ 1  1  1  1 -1 -1 -1 -1]
sage: f.close()
sage: os.remove(result_name)

sage.geometry.lattice_polytope.write_palp_matrix(m, ofile=None, comment='', format=None)¶

Write a matrix into a file.

INPUT:

m - a matrix over integers.
ofile - a file opened for writing (default: stdout)
comment - a string (default: empty) see output description
format - a format string used to print matrix entries.

OUTPUT: First line: number_of_rows number_of_columns comment Next number_of_rows lines: rows of the matrix.

EXAMPLES: This functions is used for writing polytope vertices in PALP format:

sage: o = lattice_polytope.octahedron(3)
sage: lattice_polytope.write_palp_matrix(o.vertices(), comment="3D Octahedron")
6 3D Octahedron
0  0 -1  0  0
1  0  0 -1  0
0  1  0  0 -1
sage: lattice_polytope.write_palp_matrix(o.vertices(), format="%4d")
6
  0    0   -1    0    0
  1    0    0   -1    0
  0    1    0    0   -1

Lattice and reflexive polytopes¶

Previous topic

Next topic

This Page

Navigation

Lattice and reflexive polytopes¶

Previous topic

Next topic

This Page

Quick search

Navigation