def torus(u, v):
r"""
Return the flat torus obtained as the quotient of the plane by the pair
of vectors ``u`` and ``v``.
EXAMPLES::
sage: from flatsurf import translation_surfaces
sage: T = translation_surfaces.torus((1, AA(2).sqrt()), (AA(3).sqrt(), 3))
sage: T
TranslationSurface built from 1 polygon
sage: T.polygon(0)
Polygon: (0, 0), (1, 1.414213562373095?), (2.732050807568878?, 4.414213562373095?), (1.732050807568878?, 3)
"""
u = vector(u)
v = vector(v)
field = Sequence([u, v]).universe().base_ring()
if isinstance(field, type):
field = py_scalar_parent(field)
if not field.is_field():
field = field.fraction_field()
s = Surface_list(base_ring=field)
p = polygons(vertices=[(0, 0), u, u + v, v], base_ring=field)
s.add_polygon(p, [(0, 2), (0, 3), (0, 0), (0, 1)])
s.set_immutable()
return TranslationSurface(s)
def mcmullen_L(l1, l2, l3, l4):
r"""
Return McMullen's L shaped surface with parameters l1, l2, l3, l4.
Polygon labels and lengths are marked below::
+-----+
| |
| 1 |l1
| |
| | l4
+-----+---------+
| | |
| 0 | 2 |l2
| | |
+-----+---------+
l3
EXAMPLES::
sage: from flatsurf import *
sage: s = translation_surfaces.mcmullen_L(1,1,1,1)
sage: TestSuite(s).run()
TESTS::
sage: from flatsurf import translation_surfaces
sage: translation_surfaces.mcmullen_L(1r, 1r, 1r, 1r)
TranslationSurface built from 3 polygons
"""
field = Sequence([l1, l2, l3, l4]).universe()
if isinstance(field, type):
field = py_scalar_parent(field)
if not field.is_field():
field = field.fraction_field()
s = Surface_list(base_ring=field)
s.add_polygon(
polygons((l3, 0), (0, l2), (-l3, 0), (0, -l2), ring=field))
s.add_polygon(
polygons((l3, 0), (0, l1), (-l3, 0), (0, -l1), ring=field))
s.add_polygon(
polygons((l4, 0), (0, l2), (-l4, 0), (0, -l2), ring=field))
s.change_edge_gluing(0, 0, 1, 2)
s.change_edge_gluing(0, 1, 2, 3)
s.change_edge_gluing(0, 2, 1, 0)
s.change_edge_gluing(0, 3, 2, 1)
s.change_edge_gluing(1, 1, 1, 3)
s.change_edge_gluing(2, 0, 2, 2)
s.set_immutable()
return TranslationSurface(s)
def __init__(self, parent, value, symbolic=None):
FieldElement.__init__(
self, parent) ## this is so that canonical_coercion works.
if not parent._mutable_values and value is not None:
## Test coercing the value to RR, so that we do not try to build a ParametricRealFieldElement
## from something like a tuple or vector or list or variable of a polynomial ring
## or something else that does not make any sense.
# FIXME: parent(value) caused SIGSEGV because of an infinite recursion
from sage.structure.coerce import py_scalar_parent
if hasattr(value, 'parent'):
if not RR.has_coerce_map_from(value.parent()):
raise TypeError("Value is of wrong type")
else:
if not RR.has_coerce_map_from(py_scalar_parent(type(value))):
raise TypeError("Value is of wrong type")
self._val = value
if symbolic is None:
self._sym = value # changed to not coerce into SR. -mkoeppe
else:
self._sym = symbolic
def Polyhedron(vertices=None,
rays=None,
lines=None,
ieqs=None,
eqns=None,
ambient_dim=None,
base_ring=None,
minimize=True,
verbose=False,
backend=None):
"""
Construct a polyhedron object.
You may either define it with vertex/ray/line or
inequalities/equations data, but not both. Redundant data will
automatically be removed (unless ``minimize=False``), and the
complementary representation will be computed.
INPUT:
- ``vertices`` -- list of point. Each point can be specified as
any iterable container of ``base_ring`` elements. If ``rays`` or
``lines`` are specified but no ``vertices``, the origin is
taken to be the single vertex.
- ``rays`` -- list of rays. Each ray can be specified as any
iterable container of ``base_ring`` elements.
- ``lines`` -- list of lines. Each line can be specified as any
iterable container of ``base_ring`` elements.
- ``ieqs`` -- list of inequalities. Each line can be specified as any
iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the inequality `7x_1+3x_2+4x_3\geq 1`.
- ``eqns`` -- list of equalities. Each line can be specified as
any iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the equality `7x_1+3x_2+4x_3= 1`.
- ``base_ring`` -- a sub-field of the reals implemented in
Sage. The field over which the polyhedron will be defined. For
``QQ`` and algebraic extensions, exact arithmetic will be
used. For ``RDF``, floating point numbers will be used. Floating
point arithmetic is faster but might give the wrong result for
degenerate input.
- ``ambient_dim`` -- integer. The ambient space dimension. Usually
can be figured out automatically from the H/Vrepresentation
dimensions.
- ``backend`` -- string or ``None`` (default). The backend to use. Valid choices are
* ``'cdd'``: use cdd
(:mod:`~sage.geometry.polyhedron.backend_cdd`) with `\QQ` or
`\RDF` coefficients depending on ``base_ring``.
* ``'normaliz'``: use normaliz
(:mod:`~sage.geometry.polyhedron.backend_normaliz`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``.
* ``'polymake'``: use polymake
(:mod:`~sage.geometry.polyhedron.backend_polymake`) with `\QQ`, `\RDF` or
``QuadraticField`` coefficients depending on ``base_ring``.
* ``'ppl'``: use ppl
(:mod:`~sage.geometry.polyhedron.backend_ppl`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``.
* ``'field'``: use python implementation
(:mod:`~sage.geometry.polyhedron.backend_field`) for any field
Some backends support further optional arguments:
- ``minimize`` -- boolean (default: ``True``). Whether to
immediately remove redundant H/V-representation data. Currently
not used.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes. Only supported by the cdd
backends.
OUTPUT:
The polyhedron defined by the input data.
EXAMPLES:
Construct some polyhedra::
sage: square_from_vertices = Polyhedron(vertices = [[1, 1], [1, -1], [-1, 1], [-1, -1]])
sage: square_from_ieqs = Polyhedron(ieqs = [[1, 0, 1], [1, 1, 0], [1, 0, -1], [1, -1, 0]])
sage: list(square_from_ieqs.vertex_generator())
[A vertex at (1, -1),
A vertex at (1, 1),
A vertex at (-1, 1),
A vertex at (-1, -1)]
sage: list(square_from_vertices.inequality_generator())
[An inequality (1, 0) x + 1 >= 0,
An inequality (0, 1) x + 1 >= 0,
An inequality (-1, 0) x + 1 >= 0,
An inequality (0, -1) x + 1 >= 0]
sage: p = Polyhedron(vertices = [[1.1, 2.2], [3.3, 4.4]], base_ring=RDF)
sage: p.n_inequalities()
2
The same polyhedron given in two ways::
sage: p = Polyhedron(ieqs = [[0,1,0,0],[0,0,1,0]])
sage: p.Vrepresentation()
(A line in the direction (0, 0, 1),
A ray in the direction (1, 0, 0),
A ray in the direction (0, 1, 0),
A vertex at (0, 0, 0))
sage: q = Polyhedron(vertices=[[0,0,0]], rays=[[1,0,0],[0,1,0]], lines=[[0,0,1]])
sage: q.Hrepresentation()
(An inequality (1, 0, 0) x + 0 >= 0,
An inequality (0, 1, 0) x + 0 >= 0)
Finally, a more complicated example. Take `\mathbb{R}_{\geq 0}^6` with
coordinates `a, b, \dots, f` and
* The inequality `e+b \geq c+d`
* The inequality `e+c \geq b+d`
* The equation `a+b+c+d+e+f = 31`
::
sage: positive_coords = Polyhedron(ieqs=[
....: [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
....: [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
sage: P = Polyhedron(ieqs=positive_coords.inequalities() + (
....: [0,0,1,-1,-1,1,0], [0,0,-1,1,-1,1,0]), eqns=[[-31,1,1,1,1,1,1]])
sage: P
A 5-dimensional polyhedron in QQ^6 defined as the convex hull of 7 vertices
sage: P.dim()
5
sage: P.Vrepresentation()
(A vertex at (31, 0, 0, 0, 0, 0), A vertex at (0, 0, 0, 0, 0, 31),
A vertex at (0, 0, 0, 0, 31, 0), A vertex at (0, 0, 31/2, 0, 31/2, 0),
A vertex at (0, 31/2, 31/2, 0, 0, 0), A vertex at (0, 31/2, 0, 0, 31/2, 0),
A vertex at (0, 0, 0, 31/2, 31/2, 0))
When the input contains elements of a Number Field, they require an
embedding::
sage: K = NumberField(x^2-2,'s')
sage: s = K.0
sage: L = NumberField(x^3-2,'t')
sage: t = L.0
sage: P = Polyhedron(vertices = [[0,s],[t,0]])
Traceback (most recent call last):
...
ValueError: invalid base ring
.. NOTE::
* Once constructed, a ``Polyhedron`` object is immutable.
* Although the option ``base_ring=RDF`` allows numerical data to
be used, it might not give the right answer for degenerate
input data - the results can depend upon the tolerance
setting of cdd.
TESTS:
Check that giving ``float`` input gets converted to ``RDF`` (see :trac:`22605`)::
sage: f = float(1.1)
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in RDF^1 defined as the convex hull of 1 vertex
Check that giving ``int`` input gets converted to ``ZZ`` (see :trac:`22605`)::
sage: Polyhedron(vertices=[[int(42)]])
A 0-dimensional polyhedron in ZZ^1 defined as the convex hull of 1 vertex
Check that giving ``Fraction`` input gets converted to ``QQ`` (see :trac:`22605`)::
sage: from fractions import Fraction
sage: f = Fraction(int(6), int(8))
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in QQ^1 defined as the convex hull of 1 vertex
Check that input with too many bits of precision returns an error (see
:trac:`22552`)::
sage: Polyhedron(vertices=[(8.3319544851638732, 7.0567045956967727), (6.4876921900819049, 4.8435898415984129)])
Traceback (most recent call last):
...
ValueError: for polyhedra with floating point numbers, the only allowed ring is RDF with backend 'cdd'
Check that setting ``base_ring`` to a ``RealField`` returns an error (see :trac:`22552`)::
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(40))
Traceback (most recent call last):
...
ValueError: no appropriate backend for computations with Real Field with 40 bits of precision
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(53))
Traceback (most recent call last):
...
ValueError: no appropriate backend for computations with Real Field with 53 bits of precision
"""
# Clean up the arguments
vertices = _make_listlist(vertices)
rays = _make_listlist(rays)
lines = _make_listlist(lines)
ieqs = _make_listlist(ieqs)
eqns = _make_listlist(eqns)
got_Vrep = (len(vertices + rays + lines) > 0)
got_Hrep = (len(ieqs + eqns) > 0)
if got_Vrep and got_Hrep:
raise ValueError('cannot specify both H- and V-representation.')
elif got_Vrep:
deduced_ambient_dim = _common_length_of(vertices, rays, lines)[1]
elif got_Hrep:
deduced_ambient_dim = _common_length_of(ieqs, eqns)[1] - 1
else:
if ambient_dim is None:
deduced_ambient_dim = 0
else:
deduced_ambient_dim = ambient_dim
if base_ring is None:
base_ring = ZZ
# set ambient_dim
if ambient_dim is not None and deduced_ambient_dim != ambient_dim:
raise ValueError(
'ambient space dimension mismatch. Try removing the "ambient_dim" parameter.'
)
ambient_dim = deduced_ambient_dim
# figure out base_ring
from sage.misc.flatten import flatten
from sage.structure.element import parent
from sage.categories.all import Rings, Fields
values = flatten(vertices + rays + lines + ieqs + eqns)
if base_ring is not None:
convert = any(parent(x) is not base_ring for x in values)
elif not values:
base_ring = ZZ
convert = False
else:
P = parent(values[0])
if any(parent(x) is not P for x in values):
from sage.structure.sequence import Sequence
P = Sequence(values).universe()
convert = True
else:
convert = False
from sage.structure.coerce import py_scalar_parent
if isinstance(P, type):
base_ring = py_scalar_parent(P)
convert = convert or P is not base_ring
else:
base_ring = P
if not got_Vrep and base_ring not in Fields():
base_ring = base_ring.fraction_field()
convert = True
if base_ring not in Rings():
raise ValueError('invalid base ring')
if not base_ring.is_exact():
# TODO: remove this hack?
if base_ring is RR:
base_ring = RDF
convert = True
elif base_ring is not RDF:
raise ValueError(
"for polyhedra with floating point numbers, the only allowed ring is RDF with backend 'cdd'"
)
# Add the origin if necessary
if got_Vrep and len(vertices) == 0:
vertices = [[0] * ambient_dim]
# Specific backends can override the base_ring
from sage.geometry.polyhedron.parent import Polyhedra
parent = Polyhedra(base_ring, ambient_dim, backend=backend)
base_ring = parent.base_ring()
# finally, construct the Polyhedron
Hrep = Vrep = None
if got_Hrep:
Hrep = [ieqs, eqns]
if got_Vrep:
Vrep = [vertices, rays, lines]
return parent(Vrep, Hrep, convert=convert, verbose=verbose)
def Polyhedron(vertices=None, rays=None, lines=None,
ieqs=None, eqns=None,
ambient_dim=None, base_ring=None, minimize=True, verbose=False,
backend=None):
r"""
Construct a polyhedron object.
You may either define it with vertex/ray/line or
inequalities/equations data, but not both. Redundant data will
automatically be removed (unless ``minimize=False``), and the
complementary representation will be computed.
INPUT:
- ``vertices`` -- list of point. Each point can be specified as
any iterable container of ``base_ring`` elements. If ``rays`` or
``lines`` are specified but no ``vertices``, the origin is
taken to be the single vertex.
- ``rays`` -- list of rays. Each ray can be specified as any
iterable container of ``base_ring`` elements.
- ``lines`` -- list of lines. Each line can be specified as any
iterable container of ``base_ring`` elements.
- ``ieqs`` -- list of inequalities. Each line can be specified as any
iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the inequality `7x_1+3x_2+4x_3\geq 1`.
- ``eqns`` -- list of equalities. Each line can be specified as
any iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the equality `7x_1+3x_2+4x_3= 1`.
- ``base_ring`` -- a sub-field of the reals implemented in
Sage. The field over which the polyhedron will be defined. For
``QQ`` and algebraic extensions, exact arithmetic will be
used. For ``RDF``, floating point numbers will be used. Floating
point arithmetic is faster but might give the wrong result for
degenerate input.
- ``ambient_dim`` -- integer. The ambient space dimension. Usually
can be figured out automatically from the H/Vrepresentation
dimensions.
- ``backend`` -- string or ``None`` (default). The backend to use. Valid choices are
* ``'cdd'``: use cdd
(:mod:`~sage.geometry.polyhedron.backend_cdd`) with `\QQ` or
`\RDF` coefficients depending on ``base_ring``.
* ``'normaliz'``: use normaliz
(:mod:`~sage.geometry.polyhedron.backend_normaliz`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``.
* ``'polymake'``: use polymake
(:mod:`~sage.geometry.polyhedron.backend_polymake`) with `\QQ`, `\RDF` or
``QuadraticField`` coefficients depending on ``base_ring``.
* ``'ppl'``: use ppl
(:mod:`~sage.geometry.polyhedron.backend_ppl`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``.
* ``'field'``: use python implementation
(:mod:`~sage.geometry.polyhedron.backend_field`) for any field
Some backends support further optional arguments:
- ``minimize`` -- boolean (default: ``True``). Whether to
immediately remove redundant H/V-representation data. Currently
not used.
- ``verbose`` -- boolean (default: ``False``). Whether to print
verbose output for debugging purposes. Only supported by the cdd and
normaliz backends.
OUTPUT:
The polyhedron defined by the input data.
EXAMPLES:
Construct some polyhedra::
sage: square_from_vertices = Polyhedron(vertices = [[1, 1], [1, -1], [-1, 1], [-1, -1]])
sage: square_from_ieqs = Polyhedron(ieqs = [[1, 0, 1], [1, 1, 0], [1, 0, -1], [1, -1, 0]])
sage: list(square_from_ieqs.vertex_generator())
[A vertex at (1, -1),
A vertex at (1, 1),
A vertex at (-1, 1),
A vertex at (-1, -1)]
sage: list(square_from_vertices.inequality_generator())
[An inequality (1, 0) x + 1 >= 0,
An inequality (0, 1) x + 1 >= 0,
An inequality (-1, 0) x + 1 >= 0,
An inequality (0, -1) x + 1 >= 0]
sage: p = Polyhedron(vertices = [[1.1, 2.2], [3.3, 4.4]], base_ring=RDF)
sage: p.n_inequalities()
2
The same polyhedron given in two ways::
sage: p = Polyhedron(ieqs = [[0,1,0,0],[0,0,1,0]])
sage: p.Vrepresentation()
(A line in the direction (0, 0, 1),
A ray in the direction (1, 0, 0),
A ray in the direction (0, 1, 0),
A vertex at (0, 0, 0))
sage: q = Polyhedron(vertices=[[0,0,0]], rays=[[1,0,0],[0,1,0]], lines=[[0,0,1]])
sage: q.Hrepresentation()
(An inequality (1, 0, 0) x + 0 >= 0,
An inequality (0, 1, 0) x + 0 >= 0)
Finally, a more complicated example. Take `\mathbb{R}_{\geq 0}^6` with
coordinates `a, b, \dots, f` and
* The inequality `e+b \geq c+d`
* The inequality `e+c \geq b+d`
* The equation `a+b+c+d+e+f = 31`
::
sage: positive_coords = Polyhedron(ieqs=[
....: [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
....: [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
sage: P = Polyhedron(ieqs=positive_coords.inequalities() + (
....: [0,0,1,-1,-1,1,0], [0,0,-1,1,-1,1,0]), eqns=[[-31,1,1,1,1,1,1]])
sage: P
A 5-dimensional polyhedron in QQ^6 defined as the convex hull of 7 vertices
sage: P.dim()
5
sage: P.Vrepresentation()
(A vertex at (31, 0, 0, 0, 0, 0), A vertex at (0, 0, 0, 0, 0, 31),
A vertex at (0, 0, 0, 0, 31, 0), A vertex at (0, 0, 31/2, 0, 31/2, 0),
A vertex at (0, 31/2, 31/2, 0, 0, 0), A vertex at (0, 31/2, 0, 0, 31/2, 0),
A vertex at (0, 0, 0, 31/2, 31/2, 0))
Regular icosahedron, centered at `0` with edge length `2`, with vertices given
by the cyclic shifts of `(0, \pm 1, \pm (1+\sqrt(5))/2)`, cf.
:wikipedia:`Regular_icosahedron`. It needs a number field::
sage: R0.<r0> = QQ[]
sage: R1.<r1> = NumberField(r0^2-5, embedding=AA(5)**(1/2))
sage: grat = (1+r1)/2
sage: v = [[0, 1, grat], [0, 1, -grat], [0, -1, grat], [0, -1, -grat]]
sage: pp = Permutation((1, 2, 3))
sage: icosah = Polyhedron([(pp^2).action(w) for w in v]
....: + [pp.action(w) for w in v] + v, base_ring=R1)
sage: len(icosah.faces(2))
20
When the input contains elements of a Number Field, they require an
embedding::
sage: K = NumberField(x^2-2,'s')
sage: s = K.0
sage: L = NumberField(x^3-2,'t')
sage: t = L.0
sage: P = Polyhedron(vertices = [[0,s],[t,0]])
Traceback (most recent call last):
...
ValueError: invalid base ring
.. NOTE::
* Once constructed, a ``Polyhedron`` object is immutable.
* Although the option ``base_ring=RDF`` allows numerical data to
be used, it might not give the right answer for degenerate
input data - the results can depend upon the tolerance
setting of cdd.
TESTS:
Check that giving ``float`` input gets converted to ``RDF`` (see :trac:`22605`)::
sage: f = float(1.1)
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in RDF^1 defined as the convex hull of 1 vertex
Check that giving ``int`` input gets converted to ``ZZ`` (see :trac:`22605`)::
sage: Polyhedron(vertices=[[int(42)]])
A 0-dimensional polyhedron in ZZ^1 defined as the convex hull of 1 vertex
Check that giving ``Fraction`` input gets converted to ``QQ`` (see :trac:`22605`)::
sage: from fractions import Fraction
sage: f = Fraction(int(6), int(8))
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in QQ^1 defined as the convex hull of 1 vertex
Check that input with too many bits of precision returns an error (see
:trac:`22552`)::
sage: Polyhedron(vertices=[(8.3319544851638732, 7.0567045956967727), (6.4876921900819049, 4.8435898415984129)])
Traceback (most recent call last):
...
ValueError: the only allowed inexact ring is 'RDF' with backend 'cdd'
Check that setting ``base_ring`` to a ``RealField`` returns an error (see :trac:`22552`)::
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(40))
Traceback (most recent call last):
...
ValueError: no appropriate backend for computations with Real Field with 40 bits of precision
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(53))
Traceback (most recent call last):
...
ValueError: no appropriate backend for computations with Real Field with 53 bits of precision
.. SEEALSO::
:mod:`Library of polytopes <sage.geometry.polyhedron.library>`
"""
# Clean up the arguments
vertices = _make_listlist(vertices)
rays = _make_listlist(rays)
lines = _make_listlist(lines)
ieqs = _make_listlist(ieqs)
eqns = _make_listlist(eqns)
got_Vrep = (len(vertices + rays + lines) > 0)
got_Hrep = (len(ieqs + eqns) > 0)
if got_Vrep and got_Hrep:
raise ValueError('cannot specify both H- and V-representation.')
elif got_Vrep:
deduced_ambient_dim = _common_length_of(vertices, rays, lines)[1]
elif got_Hrep:
deduced_ambient_dim = _common_length_of(ieqs, eqns)[1] - 1
else:
if ambient_dim is None:
deduced_ambient_dim = 0
else:
deduced_ambient_dim = ambient_dim
if base_ring is None:
base_ring = ZZ
# set ambient_dim
if ambient_dim is not None and deduced_ambient_dim != ambient_dim:
raise ValueError('ambient space dimension mismatch. Try removing the "ambient_dim" parameter.')
ambient_dim = deduced_ambient_dim
# figure out base_ring
from sage.misc.flatten import flatten
from sage.structure.element import parent
from sage.categories.all import Rings, Fields
values = flatten(vertices + rays + lines + ieqs + eqns)
if base_ring is not None:
convert = any(parent(x) is not base_ring for x in values)
elif not values:
base_ring = ZZ
convert = False
else:
P = parent(values[0])
if any(parent(x) is not P for x in values):
from sage.structure.sequence import Sequence
P = Sequence(values).universe()
convert = True
else:
convert = False
from sage.structure.coerce import py_scalar_parent
if isinstance(P, type):
base_ring = py_scalar_parent(P)
convert = convert or P is not base_ring
else:
base_ring = P
if not got_Vrep and base_ring not in Fields():
base_ring = base_ring.fraction_field()
convert = True
if base_ring not in Rings():
raise ValueError('invalid base ring')
if not base_ring.is_exact():
# TODO: remove this hack?
if base_ring is RR:
base_ring = RDF
convert = True
elif base_ring is not RDF:
raise ValueError("the only allowed inexact ring is 'RDF' with backend 'cdd'")
# Add the origin if necessary
if got_Vrep and len(vertices) == 0:
vertices = [[0] * ambient_dim]
# Specific backends can override the base_ring
from sage.geometry.polyhedron.parent import Polyhedra
parent = Polyhedra(base_ring, ambient_dim, backend=backend)
base_ring = parent.base_ring()
# finally, construct the Polyhedron
Hrep = Vrep = None
if got_Hrep:
Hrep = [ieqs, eqns]
if got_Vrep:
Vrep = [vertices, rays, lines]
return parent(Vrep, Hrep, convert=convert, verbose=verbose)
def Polyhedron(vertices=None,
rays=None,
lines=None,
ieqs=None,
eqns=None,
ambient_dim=None,
base_ring=None,
minimize=True,
verbose=False,
backend=None,
mutable=False):
r"""
Construct a polyhedron object.
You may either define it with vertex/ray/line or
inequalities/equations data, but not both. Redundant data will
automatically be removed (unless ``minimize=False``), and the
complementary representation will be computed.
INPUT:
- ``vertices`` -- list of points. Each point can be specified as
any iterable container of ``base_ring`` elements. If ``rays`` or
``lines`` are specified but no ``vertices``, the origin is
taken to be the single vertex.
- ``rays`` -- list of rays. Each ray can be specified as any
iterable container of ``base_ring`` elements.
- ``lines`` -- list of lines. Each line can be specified as any
iterable container of ``base_ring`` elements.
- ``ieqs`` -- list of inequalities. Each line can be specified as any
iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the inequality `7x_1+3x_2+4x_3\geq 1`.
- ``eqns`` -- list of equalities. Each line can be specified as
any iterable container of ``base_ring`` elements. An entry equal to
``[-1,7,3,4]`` represents the equality `7x_1+3x_2+4x_3= 1`.
- ``base_ring`` -- a sub-field of the reals implemented in
Sage. The field over which the polyhedron will be defined. For
``QQ`` and algebraic extensions, exact arithmetic will be
used. For ``RDF``, floating point numbers will be used. Floating
point arithmetic is faster but might give the wrong result for
degenerate input.
- ``ambient_dim`` -- integer. The ambient space dimension. Usually
can be figured out automatically from the H/Vrepresentation
dimensions.
- ``backend`` -- string or ``None`` (default). The backend to use. Valid choices are
* ``'cdd'``: use cdd
(:mod:`~sage.geometry.polyhedron.backend_cdd`) with `\QQ` or
`\RDF` coefficients depending on ``base_ring``
* ``'normaliz'``: use normaliz
(:mod:`~sage.geometry.polyhedron.backend_normaliz`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``
* ``'polymake'``: use polymake
(:mod:`~sage.geometry.polyhedron.backend_polymake`) with `\QQ`, `\RDF` or
``QuadraticField`` coefficients depending on ``base_ring``
* ``'ppl'``: use ppl
(:mod:`~sage.geometry.polyhedron.backend_ppl`) with `\ZZ` or
`\QQ` coefficients depending on ``base_ring``
* ``'field'``: use python implementation
(:mod:`~sage.geometry.polyhedron.backend_field`) for any field
Some backends support further optional arguments:
- ``minimize`` -- boolean (default: ``True``); whether to
immediately remove redundant H/V-representation data; currently
not used.
- ``verbose`` -- boolean (default: ``False``); whether to print
verbose output for debugging purposes; only supported by the cdd and
normaliz backends
- ``mutable`` -- boolean (default: ``False``); whether the polyhedron
is mutable
OUTPUT:
The polyhedron defined by the input data.
EXAMPLES:
Construct some polyhedra::
sage: square_from_vertices = Polyhedron(vertices = [[1, 1], [1, -1], [-1, 1], [-1, -1]])
sage: square_from_ieqs = Polyhedron(ieqs = [[1, 0, 1], [1, 1, 0], [1, 0, -1], [1, -1, 0]])
sage: list(square_from_ieqs.vertex_generator())
[A vertex at (1, -1),
A vertex at (1, 1),
A vertex at (-1, 1),
A vertex at (-1, -1)]
sage: list(square_from_vertices.inequality_generator())
[An inequality (1, 0) x + 1 >= 0,
An inequality (0, 1) x + 1 >= 0,
An inequality (-1, 0) x + 1 >= 0,
An inequality (0, -1) x + 1 >= 0]
sage: p = Polyhedron(vertices = [[1.1, 2.2], [3.3, 4.4]], base_ring=RDF)
sage: p.n_inequalities()
2
The same polyhedron given in two ways::
sage: p = Polyhedron(ieqs = [[0,1,0,0],[0,0,1,0]])
sage: p.Vrepresentation()
(A line in the direction (0, 0, 1),
A ray in the direction (1, 0, 0),
A ray in the direction (0, 1, 0),
A vertex at (0, 0, 0))
sage: q = Polyhedron(vertices=[[0,0,0]], rays=[[1,0,0],[0,1,0]], lines=[[0,0,1]])
sage: q.Hrepresentation()
(An inequality (1, 0, 0) x + 0 >= 0,
An inequality (0, 1, 0) x + 0 >= 0)
Finally, a more complicated example. Take `\mathbb{R}_{\geq 0}^6` with
coordinates `a, b, \dots, f` and
* The inequality `e+b \geq c+d`
* The inequality `e+c \geq b+d`
* The equation `a+b+c+d+e+f = 31`
::
sage: positive_coords = Polyhedron(ieqs=[
....: [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0],
....: [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
sage: P = Polyhedron(ieqs=positive_coords.inequalities() + (
....: [0,0,1,-1,-1,1,0], [0,0,-1,1,-1,1,0]), eqns=[[-31,1,1,1,1,1,1]])
sage: P
A 5-dimensional polyhedron in QQ^6 defined as the convex hull of 7 vertices
sage: P.dim()
5
sage: P.Vrepresentation()
(A vertex at (31, 0, 0, 0, 0, 0), A vertex at (0, 0, 0, 0, 0, 31),
A vertex at (0, 0, 0, 0, 31, 0), A vertex at (0, 0, 31/2, 0, 31/2, 0),
A vertex at (0, 31/2, 31/2, 0, 0, 0), A vertex at (0, 31/2, 0, 0, 31/2, 0),
A vertex at (0, 0, 0, 31/2, 31/2, 0))
Regular icosahedron, centered at `0` with edge length `2`, with vertices given
by the cyclic shifts of `(0, \pm 1, \pm (1+\sqrt(5))/2)`, cf.
:wikipedia:`Regular_icosahedron`. It needs a number field::
sage: R0.<r0> = QQ[] # optional - sage.rings.number_field
sage: R1.<r1> = NumberField(r0^2-5, embedding=AA(5)**(1/2)) # optional - sage.rings.number_field
sage: gold = (1+r1)/2 # optional - sage.rings.number_field
sage: v = [[0, 1, gold], [0, 1, -gold], [0, -1, gold], [0, -1, -gold]] # optional - sage.rings.number_field
sage: pp = Permutation((1, 2, 3)) # optional - sage.combinat # optional - sage.rings.number_field
sage: icosah = Polyhedron( # optional - sage.combinat # optional - sage.rings.number_field
....: [(pp^2).action(w) for w in v] + [pp.action(w) for w in v] + v,
....: base_ring=R1)
sage: len(icosah.faces(2)) # optional - sage.combinat # optional - sage.rings.number_field
20
When the input contains elements of a Number Field, they require an
embedding::
sage: K = NumberField(x^2-2,'s') # optional - sage.rings.number_field
sage: s = K.0 # optional - sage.rings.number_field
sage: L = NumberField(x^3-2,'t') # optional - sage.rings.number_field
sage: t = L.0 # optional - sage.rings.number_field
sage: P = Polyhedron(vertices = [[0,s],[t,0]]) # optional - sage.rings.number_field
Traceback (most recent call last):
...
ValueError: invalid base ring
Create a mutable polyhedron::
sage: P = Polyhedron(vertices=[[0, 1], [1, 0]], mutable=True)
sage: P.is_mutable()
True
sage: hasattr(P, "_Vrepresentation")
False
sage: P.Vrepresentation()
(A vertex at (0, 1), A vertex at (1, 0))
sage: hasattr(P, "_Vrepresentation")
True
.. NOTE::
* Once constructed, a ``Polyhedron`` object is immutable.
* Although the option ``base_ring=RDF`` allows numerical data to
be used, it might not give the right answer for degenerate
input data - the results can depend upon the tolerance
setting of cdd.
TESTS:
Check that giving ``float`` input gets converted to ``RDF`` (see :trac:`22605`)::
sage: f = float(1.1)
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in RDF^1 defined as the convex hull of 1 vertex
Check that giving ``int`` input gets converted to ``ZZ`` (see :trac:`22605`)::
sage: Polyhedron(vertices=[[int(42)]])
A 0-dimensional polyhedron in ZZ^1 defined as the convex hull of 1 vertex
Check that giving ``Fraction`` input gets converted to ``QQ`` (see :trac:`22605`)::
sage: from fractions import Fraction
sage: f = Fraction(int(6), int(8))
sage: Polyhedron(vertices=[[f]])
A 0-dimensional polyhedron in QQ^1 defined as the convex hull of 1 vertex
Check that non-compact polyhedra given by V-representation have base ring ``QQ``,
not ``ZZ`` (see :trac:`27840`)::
sage: Q = Polyhedron(vertices=[(1, 2, 3), (1, 3, 2), (2, 1, 3),
....: (2, 3, 1), (3, 1, 2), (3, 2, 1)],
....: rays=[[1, 1, 1]], lines=[[1, 2, 3]], backend='ppl')
sage: Q.base_ring()
Rational Field
Check that enforcing base ring `ZZ` for this example gives an error::
sage: Q = Polyhedron(vertices=[(1, 2, 3), (1, 3, 2), (2, 1, 3),
....: (2, 3, 1), (3, 1, 2), (3, 2, 1)],
....: rays=[[1, 1, 1]], lines=[[1, 2, 3]], backend='ppl',
....: base_ring=ZZ)
Traceback (most recent call last):
...
TypeError: no conversion of this rational to integer
Check that input with too many bits of precision returns an error (see
:trac:`22552`)::
sage: Polyhedron(vertices=[(8.3319544851638732, 7.0567045956967727), (6.4876921900819049, 4.8435898415984129)])
Traceback (most recent call last):
...
ValueError: the only allowed inexact ring is 'RDF' with backend 'cdd'
Check that setting ``base_ring`` to a ``RealField`` returns an error (see :trac:`22552`)::
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(40))
Traceback (most recent call last):
...
ValueError: no default backend for computations with Real Field with 40 bits of precision
sage: Polyhedron(vertices =[(8.3, 7.0), (6.4, 4.8)], base_ring=RealField(53))
Traceback (most recent call last):
...
ValueError: no default backend for computations with Real Field with 53 bits of precision
Check that :trac:`17339` is fixed::
sage: Polyhedron(ambient_dim=0, ieqs=[], eqns=[[1]], base_ring=QQ)
The empty polyhedron in QQ^0
sage: P = Polyhedron(ambient_dim=0, ieqs=[], eqns=[], base_ring=QQ); P
A 0-dimensional polyhedron in QQ^0 defined as the convex hull of 1 vertex
sage: P.Vrepresentation()
(A vertex at (),)
sage: Polyhedron(ambient_dim=2, ieqs=[], eqns=[], base_ring=QQ)
A 2-dimensional polyhedron in QQ^2 defined as the convex hull
of 1 vertex and 2 lines
sage: Polyhedron(ambient_dim=2, ieqs=[], eqns=[], base_ring=QQ, backend='field')
A 2-dimensional polyhedron in QQ^2 defined as the convex hull
of 1 vertex and 2 lines
sage: Polyhedron(ambient_dim=0, ieqs=[], eqns=[[1]], base_ring=QQ, backend="cdd")
The empty polyhedron in QQ^0
sage: Polyhedron(ambient_dim=0, ieqs=[], eqns=[[1]], base_ring=QQ, backend="ppl")
The empty polyhedron in QQ^0
sage: Polyhedron(ambient_dim=0, ieqs=[], eqns=[[1]], base_ring=QQ, backend="field")
The empty polyhedron in QQ^0
sage: Polyhedron(ambient_dim=2, vertices=[], rays=[], lines=[], base_ring=QQ)
The empty polyhedron in QQ^2
.. SEEALSO::
:mod:`Library of polytopes <sage.geometry.polyhedron.library>`
"""
got_Vrep = not ((vertices is None) and (rays is None) and (lines is None))
got_Hrep = not ((ieqs is None) and (eqns is None))
# Clean up the arguments
vertices = _make_listlist(vertices)
rays = _make_listlist(rays)
lines = _make_listlist(lines)
ieqs = _make_listlist(ieqs)
eqns = _make_listlist(eqns)
if got_Vrep and got_Hrep:
raise ValueError('cannot specify both H- and V-representation.')
elif got_Vrep:
deduced_ambient_dim = _common_length_of(vertices, rays, lines)[1]
if deduced_ambient_dim is None:
if ambient_dim is not None:
deduced_ambient_dim = ambient_dim
else:
deduced_ambient_dim = 0
elif got_Hrep:
deduced_ambient_dim = _common_length_of(ieqs, eqns)[1]
if deduced_ambient_dim is None:
if ambient_dim is not None:
deduced_ambient_dim = ambient_dim
else:
deduced_ambient_dim = 0
else:
deduced_ambient_dim -= 1
else:
if ambient_dim is None:
deduced_ambient_dim = 0
else:
deduced_ambient_dim = ambient_dim
if base_ring is None:
base_ring = ZZ
# set ambient_dim
if ambient_dim is not None and deduced_ambient_dim != ambient_dim:
raise ValueError(
'ambient space dimension mismatch. Try removing the "ambient_dim" parameter.'
)
ambient_dim = deduced_ambient_dim
# figure out base_ring
from sage.misc.flatten import flatten
from sage.structure.element import parent
from sage.categories.fields import Fields
from sage.categories.rings import Rings
values = flatten(vertices + rays + lines + ieqs + eqns)
if base_ring is not None:
convert = any(parent(x) is not base_ring for x in values)
elif not values:
base_ring = ZZ
convert = False
else:
P = parent(values[0])
if any(parent(x) is not P for x in values):
from sage.structure.sequence import Sequence
P = Sequence(values).universe()
convert = True
else:
convert = False
from sage.structure.coerce import py_scalar_parent
if isinstance(P, type):
base_ring = py_scalar_parent(P)
convert = convert or P is not base_ring
else:
base_ring = P
if base_ring not in Fields():
got_compact_Vrep = got_Vrep and not rays and not lines
got_cone_Vrep = got_Vrep and all(
all(x == 0 for x in v) for v in vertices)
if not got_compact_Vrep and not got_cone_Vrep:
base_ring = base_ring.fraction_field()
convert = True
if base_ring not in Rings():
raise ValueError('invalid base ring')
try:
from sage.symbolic.ring import SR
except ImportError:
SR = None
if base_ring is not SR and not base_ring.is_exact():
# TODO: remove this hack?
if base_ring is RR:
base_ring = RDF
convert = True
elif base_ring is not RDF:
raise ValueError(
"the only allowed inexact ring is 'RDF' with backend 'cdd'"
)
# Add the origin if necessary
if got_Vrep and len(vertices) == 0 and len(rays + lines) > 0:
vertices = [[0] * ambient_dim]
# Specific backends can override the base_ring
from sage.geometry.polyhedron.parent import Polyhedra
parent = Polyhedra(base_ring, ambient_dim, backend=backend)
base_ring = parent.base_ring()
# finally, construct the Polyhedron
Hrep = Vrep = None
if got_Hrep:
Hrep = [ieqs, eqns]
if got_Vrep:
Vrep = [vertices, rays, lines]
return parent(Vrep,
Hrep,
convert=convert,
verbose=verbose,
mutable=mutable)
def cathedral(a, b):
r"""
Return the cathedral surface with parameters ``a`` and ``b``.
For any parameter ``a`` and ``b``, the cathedral surface belongs to the
so-called Gothic locus described in McMullen, Mukamel, Wright "Cubic
curves and totally geodesic subvarieties of moduli space" (2017).
1
<--->
/\ 2a
/ \ +------+
a b| | a / \
+----+ +---+ +
| | | | |
1| P0 |P1 |P2 | P3 |
| | | | |
+----+ +---+ +
b| | \ /
\ / +------+
\/
If a and b satisfies
.. MATH::
a = x + y \sqrt(d) \qquad b = -3x -3/2 + 3y \sqrt(d)
for some rational x,y and d >= 0 then it is a Teichmüller curve.
EXAMPLES::
sage: from flatsurf import translation_surfaces
sage: C = translation_surfaces.cathedral(1,2)
sage: C.stratum()
H_4(2^3)
sage: TestSuite(C).run()
"""
field = Sequence([a, b]).universe()
if isinstance(field, type):
field = py_scalar_parent(field)
if not field.is_field():
field = field.fraction_field()
a = field(a)
b = field(b)
P = ConvexPolygons(field)
s = Surface_list(base_ring=field)
half = QQ((1, 2))
p0 = P(vertices=[(0, 0), (a, 0), (a, 1), (0, 1)])
p1 = P(vertices=[(a, 0), (a, -b), (a + half, -b - half), (
a + 1, -b), (a + 1,
0), (a + 1,
1), (a + 1,
b + 1), (a + half,
b + 1 + half), (a, b + 1), (a, 1)])
p2 = P(vertices=[(a + 1, 0), (2 * a + 1, 0), (2 * a + 1, 1), (a + 1,
1)])
p3 = P(vertices=[(2 * a + 1, 0), (
2 * a + 1 + half,
-half), (4 * a + 1 + half,
-half), (4 * a + 2,
0), (4 * a + 2,
1), (4 * a + 1 + half,
1 + half), (2 * a + 1 + half,
1 + half), (2 * a + 1, 1)])
s.add_polygon(p0)
s.add_polygon(p1)
s.add_polygon(p2)
s.add_polygon(p3)
s.set_edge_pairing(0, 0, 0, 2)
s.set_edge_pairing(0, 1, 1, 9)
s.set_edge_pairing(0, 3, 3, 3)
s.set_edge_pairing(1, 0, 1, 3)
s.set_edge_pairing(1, 1, 3, 4)
s.set_edge_pairing(1, 2, 3, 6)
s.set_edge_pairing(1, 4, 2, 3)
s.set_edge_pairing(1, 5, 1, 8)
s.set_edge_pairing(1, 6, 3, 0)
s.set_edge_pairing(1, 7, 3, 2)
s.set_edge_pairing(2, 0, 2, 2)
s.set_edge_pairing(2, 1, 3, 7)
s.set_edge_pairing(3, 1, 3, 5)
s.set_immutable()
return TranslationSurface(s)