r"""
The category of polygons in the real plane with fixed rational
angles.
This module provides a common structure for all polygons with certain fixed
angles.
See :mod:`flatsurf.geometry.categories` for a general description of the
category framework in sage-flatsurf.
Normally, you won't create this (or any other) category directly. The correct
category is automatically determined for polygons.
EXAMPLES:
The category of rectangles::
sage: from flatsurf.geometry.categories import EuclideanPolygons
sage: C = EuclideanPolygons(QQ).WithAngles([1, 1, 1, 1])
It is often tedious to create this category manually, since you need to
determine a base ring that can describe the coordinates of polygons with such
angles::
sage: C = EuclideanPolygons(QQ).WithAngles([1, 1, 1])
sage: C.slopes()
Traceback (most recent call last):
...
TypeError: Unable to coerce c to a rational
sage: C = EuclideanPolygons(AA).WithAngles([1, 1, 1])
sage: C.slopes()
[(1, 0), (-0.5773502691896258?, 1), (-0.5773502691896258?, -1)]
Instead, we can use :func:`~.polygon.EuclideanPolygonsWithAngles` to create this category
over a minimal number field::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: C = EuclideanPolygonsWithAngles([1, 1, 1])
sage: C.slopes()
[(1, 0), (-c, 3), (-c, -3)]
The category of polygons is automatically determined when using
:func:`~.polygon.Polygon`::
sage: from flatsurf import Polygon
sage: p = Polygon(angles=(1, 1, 1))
sage: p.category()
Category of convex simple euclidean equilateral triangles over Number Field in c with defining polynomial x^2 - 3 with c = 1.732050807568878?
However, it can be very costly to determine that a polygon is rational and what
its actual angles are (the "equilateral" in the previous example). Therefore,
the category might get refined once these aspects have been determined::
sage: p = Polygon(edges=[(1, 0), (0, 1), (-1, 0), (0, -1)])
sage: p.category()
Category of convex simple euclidean polygons over Rational Field
sage: p.is_rational()
True
sage: p.category()
Category of rational convex simple euclidean polygons over Rational Field
sage: p.angles()
(1/4, 1/4, 1/4, 1/4)
sage: p.category()
Category of convex simple euclidean rectangles over Rational Field
Note that SageMath applies the same strategy when determining whether the
integers modulo N are a field::
sage: K = Zmod(1361)
sage: K.category()
Join of Category of finite commutative rings and Category of subquotients of monoids and Category of quotients of semigroups and Category of finite enumerated sets
sage: K.is_field()
True
sage: K.category()
Join of Category of finite enumerated fields and Category of subquotients of monoids and Category of quotients of semigroups
"""
# ****************************************************************************
# This file is part of sage-flatsurf.
#
# Copyright (C) 2016-2020 Vincent Delecroix
# 2020-2023 Julian Rüth
#
# sage-flatsurf is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# sage-flatsurf is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with sage-flatsurf. If not, see <https://www.gnu.org/licenses/>.
# ****************************************************************************
from sage.misc.cachefunc import cached_method, cached_function
from sage.categories.category_types import Category_over_base_ring
from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
from flatsurf.geometry.categories.euclidean_polygons import EuclideanPolygons
[docs]
class EuclideanPolygonsWithAngles(Category_over_base_ring):
r"""
The category of euclidean polygons with fixed rational angles.
EXAMPLES::
sage: from flatsurf.geometry.categories import EuclideanPolygons
sage: C = EuclideanPolygons(QQ).WithAngles([1, 1, 1, 1])
TESTS::
sage: TestSuite(C).run()
"""
def __init__(self, base_ring, angles):
self._angles = angles
super().__init__(base_ring)
[docs]
def super_categories(self):
r"""
Return the other categories such polygons are automatically members of,
namely, the category of rational euclidean polygons polygons.
EXAMPLES::
sage: from flatsurf.geometry.categories import EuclideanPolygons
sage: C = EuclideanPolygons(QQ).WithAngles([1, 1, 1, 1])
sage: C.super_categories()
[Category of rational euclidean polygons over Rational Field]
"""
return [EuclideanPolygons(self.base_ring()).Rational()]
@staticmethod
def _normalize_angles(angles):
r"""
Return ``angles`` normalized such that they sum to n/2-1 where ``n`` is
the number of angles, i.e., they scale to the angle in an n-gon divided
by π.
EXAMPLES::
sage: from flatsurf.geometry.categories import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles._normalize_angles([1, 1, 1, 1])
(1/4, 1/4, 1/4, 1/4)
sage: EuclideanPolygonsWithAngles._normalize_angles([1, 2, 3, 4])
(1/10, 1/5, 3/10, 2/5)
sage: EuclideanPolygonsWithAngles._normalize_angles([1, 2, 3])
(1/12, 1/6, 1/4)
"""
n = len(angles)
if n < 3:
raise ValueError("there must be at least three angles")
from sage.all import QQ, ZZ
angles = [QQ.coerce(a) for a in angles]
if any(angle <= 0 for angle in angles):
raise ValueError("angles must be positive rationals")
# Store each angle as a multiple of 2π, i.e., normalize them such their sum is (n - 2)/2.
angles = [a / sum(angles) for a in angles]
angles = [a * ZZ(n - 2) / 2 for a in angles]
if any(angle <= 0 or angle >= 1 for angle in angles):
raise NotImplementedError("each angle must be in (0, 2π)")
angles = tuple(angles)
return angles
@cached_method
def _slopes(self):
slopes = _slopes(self._angles)
# We bring the slopes first into the minimal number field in which they
# are defined since otherwise conversion from the cosines ring to the
# base_ring might fail. E.g., when the base ring is the exact-reals
# over the minimal base ring.
minimal_base_ring = _base_ring(self._angles)
slopes = [
(minimal_base_ring(slope[0]), minimal_base_ring(slope[1]))
for slope in slopes
]
return [
(self.base_ring()(slope[0]), self.base_ring()(slope[1])) for slope in slopes
]
@cached_method
def _cosines_ring(self):
slopes = _slopes(self._angles)
return slopes[0][0].parent()
def _repr_object_names(self):
r"""
Helper method to create the name of this category.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles([1/6, 1/6, 1/6])
Category of simple euclidean equilateral triangles over Number Field in c with defining polynomial x^2 - 3 with c = 1.732050807568878?
sage: EuclideanPolygonsWithAngles([1/4, 1/4, 1/4, 1/4])
Category of simple euclidean rectangles over Rational Field
sage: EuclideanPolygonsWithAngles([1/10, 2/10, 3/10, 4/10])
Category of simple euclidean quadrilaterals with angles (1/10, 1/5, 3/10, 2/5) over Number Field in c with defining polynomial x^4 - 5*x^2 + 5 with c = 1.902113032590308?
"""
names = super()._repr_object_names()
equiangular = len(set(self._angles)) == 1
from flatsurf.geometry.categories.polygons import Polygons
_, _, polygons = Polygons._describe_polygon(
len(self._angles), equiangular=equiangular
)
with_angles = "" if equiangular else f" with angles {self.angles(False)}"
return names.replace(" with angles", with_angles).replace("polygons", polygons)
[docs]
class ParentMethods:
r"""
Provides methods available to all polygons with known angles.
If you want to add functionality to all such polygons, you probably
want to put it here.
"""
[docs]
def is_convex(self, strict=False):
r"""
Return whether this is a convex polygon.
INPUT:
- ``strict`` -- whether to check for strict convexity, i.e., a
polygon with a π angle is not considered convex.
EXAMPLES::
sage: from flatsurf import polygons
sage: S = polygons.square()
sage: S.is_convex()
True
sage: S.is_convex(strict=True)
True
"""
return self.category().is_convex()
[docs]
def angle(self, e, numerical=None, assume_rational=None):
r"""
Return the angle at the beginning of the start point of the edge ``e``.
EXAMPLES::
sage: from flatsurf.geometry.polygon import polygons
sage: polygons.square().angle(0)
1/4
sage: polygons.regular_ngon(8).angle(0)
3/8
sage: from flatsurf import Polygon
sage: T = Polygon(vertices=[(0,0), (3,1), (1,5)])
sage: [T.angle(i, numerical=True) for i in range(3)] # abs tol 1e-13
[0.16737532973071603, 0.22741638234956674, 0.10520828791971722]
sage: sum(T.angle(i, numerical=True) for i in range(3)) # abs tol 1e-13
0.5
"""
if assume_rational is not None:
import warnings
warnings.warn(
"assume_rational has been deprecated as a keyword to angle() and will be removed from a future version of sage-flatsurf"
)
if numerical is None:
numerical = not self.is_rational()
if numerical:
import warnings
warnings.warn(
"the behavior of angle() has been changed in recent versions of sage-flatsurf; for non-rational polygons, numerical=True must be set explicitly to get a numerical approximation of the angle"
)
angle = self.category().angles()[e]
if numerical:
from sage.all import RR
angle = RR(angle)
return angle
[docs]
class SubcategoryMethods:
[docs]
def is_convex(self, strict=False):
r"""
Return whether the polygons in this category are convex.
INPUT:
- ``strict`` -- a boolean (default: ``False``); whether only to
consider polygons convex if all angles are <π.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(1, 2, 5).is_convex()
True
sage: EuclideanPolygonsWithAngles(2, 2, 3, 13).is_convex()
False
::
sage: E = EuclideanPolygonsWithAngles([1, 1, 1, 1, 2])
sage: E.angles()
(1/4, 1/4, 1/4, 1/4, 1/2)
sage: E.is_convex(strict=False)
True
sage: E.is_convex(strict=True)
False
"""
if strict:
return all(2 * a < 1 for a in self.angles())
return all(2 * a <= 1 for a in self.angles())
[docs]
def convexity(self):
r"""
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(1, 2, 5).convexity()
doctest:warning
...
UserWarning: convexity() has been deprecated and will be removed in a future version of sage-flatsurf; use is_convex() instead
True
sage: EuclideanPolygonsWithAngles(2, 2, 3, 13).convexity()
False
"""
import warnings
warnings.warn(
"convexity() has been deprecated and will be removed in a future version of sage-flatsurf; use is_convex() instead"
)
return self.is_convex()
[docs]
def strict_convexity(self):
r"""
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: E = EuclideanPolygonsWithAngles([1, 1, 1, 1, 2])
sage: E.angles()
(1/4, 1/4, 1/4, 1/4, 1/2)
sage: E.convexity()
True
sage: E.strict_convexity()
doctest:warning
...
UserWarning: strict_convexity() has been deprecated and will be removed in a future version of sage-flatsurf; use is_convex(strict=True) instead
False
"""
import warnings
warnings.warn(
"strict_convexity() has been deprecated and will be removed in a future version of sage-flatsurf; use is_convex(strict=True) instead"
)
return self.is_convex(strict=True)
[docs]
def angles(self, integral=False):
r"""
Return the interior angles of this polygon as multiples of 2π.
INPUT:
- ``integral`` -- a boolean (default: ``False``); whether to return
the angles not as multiples of 2π but rescaled so that they have
no denominators.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: E = EuclideanPolygonsWithAngles(1, 1, 1, 2, 6)
sage: E.angles()
(3/22, 3/22, 3/22, 3/11, 9/11)
When ``integral`` is set, the output is scaled to eliminate
denominators::
sage: E.angles(integral=True)
(1, 1, 1, 2, 6)
"""
angles = self.__angles()
if integral:
from sage.all import lcm, ZZ, gcd
C = lcm([a.denominator() for a in self.angles()]) / gcd(
[a.numerator() for a in self.angles()]
)
angles = tuple(ZZ(C * a) for a in angles)
return angles
@cached_method
def __angles(self):
r"""
Helper method for :meth:`angles` to lookup the stored angles if
this is a subcategory of :class:`EuclideanPolygonsWithAngles`.
"""
if isinstance(self, EuclideanPolygonsWithAngles):
return self._angles
for category in self.all_super_categories():
if isinstance(category, EuclideanPolygonsWithAngles):
return category._angles
assert (
False
), "EuclideanPolygonsWithAngles should be a supercategory of this category"
[docs]
def slopes(self, e0=(1, 0)):
r"""
Return the slopes of the edges as a list of vectors.
INPUT:
- ``e0`` -- the first slope returned (default: ``(1, 0)``)
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(1, 2, 1, 2).slopes()
[(1, 0), (c, 3), (-1, 0), (-c, -3)]
"""
V = self.base_ring() ** 2
slopes = self.__slopes()
n = len(slopes)
cosines = [x[0] for x in slopes]
sines = [x[1] for x in slopes]
e = V(e0)
edges = [e]
for i in range(n - 1):
e = (
-cosines[i + 1] * e[0] - sines[i + 1] * e[1],
sines[i + 1] * e[0] - cosines[i + 1] * e[1],
)
from flatsurf.geometry.euclidean import projectivization
e = projectivization(*e)
edges.append(V(e))
return edges
@cached_method
def __slopes(self):
r"""
Helper method for :meth:`slopes` to lookup the stored slopes if
this is a subcategory of :class:`EuclideanPolygonsWithAngles`.
"""
if isinstance(self, EuclideanPolygonsWithAngles):
return self._slopes()
for category in self.all_super_categories():
if isinstance(category, EuclideanPolygonsWithAngles):
return category._slopes()
assert (
False
), "EuclideanPolygonsWithAngles should be a supercategory of this category"
# TODO: rather than lengths, it would be more convenient to have access
# to the tangent space (that is the space of possible holonomies). However,
# since it is not defined over the real numbers, there are several possible ways
# to handle the data.
# TODO: here we ignored the direction SO(2) which provides additional symmetry
# in the tangent space
[docs]
@cached_method
def lengths_polytope(self):
r"""
Return the polytope parametrizing the admissible vectors data.
This polytope parametrizes the tangent space to the set of these
equiangular polygons. Be careful that even though the lengths are
admissible, they may not define a polygon without intersection.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(1, 2, 1, 2).lengths_polytope()
A 2-dimensional polyhedron in (Number Field in c with defining polynomial x^2 - 3 with c = 1.732050807568878?)^4 defined as the convex hull of 1 vertex and 2 rays
"""
n = len(self.angles())
slopes = self.slopes()
eqns = [[0] + [s[0] for s in slopes], [0] + [s[1] for s in slopes]]
ieqs = []
for i in range(n):
ieq = [0] * (n + 1)
ieq[i + 1] = 1
ieqs.append(ieq)
from sage.geometry.polyhedron.constructor import Polyhedron
return Polyhedron(eqns=eqns, ieqs=ieqs, base_ring=self.base_ring())
[docs]
def an_element(self):
r"""
Return a polygon in this category.
Since currently polygons must not be self-intersecting, the
construction used might fail.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(4, 3, 4, 4, 3, 4).an_element()
Polygon(vertices=[(0, 0),
(1/22*c + 1, 0),
(9*c^9 + 1/2*c^8 - 88*c^7 - 9/2*c^6 + 297*c^5 + 27/2*c^4 - 396*c^3 - 15*c^2 + 3631/22*c + 11/2, 1/2*c + 11),
(16*c^9 + c^8 - 154*c^7 - 9*c^6 + 506*c^5 + 27*c^4 - 638*c^3 - 30*c^2 + 4841/22*c + 9, c + 22),
(16*c^9 + c^8 - 154*c^7 - 9*c^6 + 506*c^5 + 27*c^4 - 638*c^3 - 30*c^2 + 220*c + 8, c + 22),
(7*c^9 + 1/2*c^8 - 66*c^7 - 9/2*c^6 + 209*c^5 + 27/2*c^4 - 242*c^3 - 15*c^2 + 55*c + 7/2, 1/2*c + 11)])
"""
from flatsurf import Polygon
p = Polygon(angles=self.angles())
if p not in self: # pylint: disable=unsupported-membership-test
raise NotImplementedError(
"cannot create an element in this category yet"
)
return p
[docs]
def random_element(self, ring=None, **kwds):
r"""
Return a random polygon in this category.
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: EuclideanPolygonsWithAngles(1, 1, 1, 2, 5).random_element()
Polygon(vertices=[(0, 0), ...])
sage: EuclideanPolygonsWithAngles(1,1,1,15,15,15).random_element()
Polygon(vertices=[(0, 0), ...])
sage: EuclideanPolygonsWithAngles(1,15,1,15,1,15).random_element()
Polygon(vertices=[(0, 0), ...])
"""
if ring is None:
from sage.all import QQ
ring = QQ
rays = [r.vector() for r in self.lengths_polytope().rays()]
def random_element():
while True:
coeffs = []
while len(coeffs) < len(rays):
x = ring.random_element(**kwds)
while x < 0:
x = ring.random_element(**kwds)
coeffs.append(x)
sol = sum(c * r for c, r in zip(coeffs, rays))
if all(x > 0 for x in sol):
return coeffs, sol
while True:
coeffs, lengths = random_element()
edges = [
length * slope for (length, slope) in zip(lengths, self.slopes())
]
from flatsurf import Polygon
p = Polygon(edges=edges, check=False)
from flatsurf.geometry.categories import EuclideanPolygons
if not EuclideanPolygons.ParentMethods.is_simple(p):
continue
p = Polygon(edges=edges, angles=self.angles(), check=False)
break
if p not in self: # pylint: disable=unsupported-membership-test
raise NotImplementedError(
"cannot create a random element in this category yet"
)
return p
[docs]
def billiard_unfolding_angles(self, cover_type="translation"):
r"""
Return the angles of the unfolding rational, half-translation or translation surface.
INPUT:
- ``cover_type`` (optional, default ``"translation"``) - either ``"rational"``,
``"half-translation"`` or ``"translation"``
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: E = EuclideanPolygonsWithAngles(1, 2, 5)
sage: E.billiard_unfolding_angles(cover_type="rational")
{1/8: 1, 1/4: 1, 5/8: 1}
sage: (1/8 - 1) + (1/4 - 1) + (5/8 - 1) # Euler characteristic (of the sphere)
-2
sage: E.billiard_unfolding_angles(cover_type="half-translation")
{1/2: 3, 5/2: 1}
sage: E.billiard_unfolding_angles(cover_type="translation")
{1: 3, 5: 1}
sage: E = EuclideanPolygonsWithAngles(1, 3, 1, 7)
sage: E.billiard_unfolding_angles(cover_type="rational")
{1/6: 2, 1/2: 1, 7/6: 1}
sage: 2 * (1/6 - 1) + (1/2 - 1) + (7/6 - 1) # Euler characteristic
-2
sage: E.billiard_unfolding_angles(cover_type="half-translation")
{1/2: 5, 7/2: 1}
sage: E.billiard_unfolding_angles(cover_type="translation")
{1: 5, 7: 1}
sage: E = EuclideanPolygonsWithAngles(1, 3, 5, 7)
sage: E.billiard_unfolding_angles(cover_type="rational")
{1/8: 1, 3/8: 1, 5/8: 1, 7/8: 1}
sage: (1/8 - 1) + (3/8 - 1) + (5/8 - 1) + (7/8 - 1) # Euler characteristic
-2
sage: E.billiard_unfolding_angles(cover_type="half-translation")
{1/2: 1, 3/2: 1, 5/2: 1, 7/2: 1}
sage: E.billiard_unfolding_angles(cover_type="translation")
{1: 1, 3: 1, 5: 1, 7: 1}
sage: E = EuclideanPolygonsWithAngles(1, 2, 8)
sage: E.billiard_unfolding_angles(cover_type="rational")
{1/11: 1, 2/11: 1, 8/11: 1}
sage: (1/11 - 1) + (2/11 - 1) + (8/11 - 1) # Euler characteristic
-2
sage: E.billiard_unfolding_angles(cover_type="half-translation")
{1: 1, 2: 1, 8: 1}
sage: E.billiard_unfolding_angles(cover_type="translation")
{1: 1, 2: 1, 8: 1}
"""
rat_angles = {}
for a in self.angles():
if 2 * a in rat_angles:
rat_angles[2 * a] += 1
else:
rat_angles[2 * a] = 1
if cover_type == "rational":
return rat_angles
from sage.all import lcm
N = lcm([x.denominator() for x in rat_angles])
if N % 2:
N *= 2
cov_angles = {}
for x, mult in rat_angles.items():
y = x.numerator()
d = x.denominator()
if d % 2:
d *= 2
else:
y = y / 2
assert N % d == 0
if y in cov_angles:
cov_angles[y] += mult * N // d
else:
cov_angles[y] = mult * N // d
if cover_type == "translation" and any(
y.denominator() == 2 for y in cov_angles
):
covcov_angles = {}
for y, mult in cov_angles.items():
yy = y.numerator()
if yy not in covcov_angles:
covcov_angles[yy] = 0
covcov_angles[yy] += 2 // y.denominator() * mult
return covcov_angles
elif cover_type == "half-translation" or cover_type == "translation":
return cov_angles
else:
raise ValueError("unknown 'cover_type' {!r}".format(cover_type))
[docs]
def billiard_unfolding_stratum(
self, cover_type="translation", marked_points=False
):
r"""
Return the stratum of quadratic or Abelian differential obtained by
unfolding a billiard in a polygon of this equiangular family.
INPUT:
- ``cover_type`` (optional, default ``"translation"``) - either ``"rational"``,
``"half-translation"`` or ``"translation"``
- ``marked_poins`` (optional, default ``False``) - whether the stratum should
have regular marked points
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles, similarity_surfaces
sage: E = EuclideanPolygonsWithAngles(1, 2, 5)
sage: E.billiard_unfolding_stratum("half-translation")
Q_1(3, -1^3)
sage: E.billiard_unfolding_stratum("translation")
H_3(4)
sage: E.billiard_unfolding_stratum("half-translation", True)
Q_1(3, -1^3)
sage: E.billiard_unfolding_stratum("translation", True)
H_3(4, 0^3)
sage: E = EuclideanPolygonsWithAngles(1, 3, 1, 7)
sage: E.billiard_unfolding_stratum("half-translation")
Q_1(5, -1^5)
sage: E.billiard_unfolding_stratum("translation")
H_4(6)
sage: E.billiard_unfolding_stratum("half-translation", True)
Q_1(5, -1^5)
sage: E.billiard_unfolding_stratum("translation", True)
H_4(6, 0^5)
sage: P = E.an_element()
sage: S = similarity_surfaces.billiard(P)
sage: S.minimal_cover("half-translation").stratum()
Q_1(5, -1^5)
sage: S.minimal_cover("translation").stratum()
H_4(6, 0^5)
sage: E = EuclideanPolygonsWithAngles(1, 3, 5, 7)
sage: E.billiard_unfolding_stratum("half-translation")
Q_3(5, 3, 1, -1)
sage: E.billiard_unfolding_stratum("translation")
H_7(6, 4, 2)
sage: P = E.an_element()
sage: S = similarity_surfaces.billiard(P)
sage: S.minimal_cover("half-translation").stratum()
Q_3(5, 3, 1, -1)
sage: S.minimal_cover("translation").stratum()
H_7(6, 4, 2, 0)
sage: E = EuclideanPolygonsWithAngles(1, 2, 8)
sage: E.billiard_unfolding_stratum("half-translation")
H_5(7, 1)
sage: E.billiard_unfolding_stratum("translation")
H_5(7, 1)
sage: E.billiard_unfolding_stratum("half-translation", True)
H_5(7, 1, 0)
sage: E.billiard_unfolding_stratum("translation", True)
H_5(7, 1, 0)
sage: E = EuclideanPolygonsWithAngles(9, 6, 3, 2)
sage: p = E.an_element()
sage: B = similarity_surfaces.billiard(p)
sage: B.minimal_cover("half-translation").stratum()
Q_4(7, 4, 1, 0)
sage: E.billiard_unfolding_stratum("half-translation", True)
Q_4(7, 4, 1, 0)
sage: B.minimal_cover("translation").stratum()
H_8(8, 2^3, 0^2)
sage: E.billiard_unfolding_stratum("translation", True)
H_8(8, 2^3, 0^2)
"""
from sage.all import ZZ
angles = self.billiard_unfolding_angles(cover_type)
from surface_dynamics import Stratum
if all(a.is_integer() for a in angles):
if not marked_points and len(angles) == 1 and 1 in angles:
return Stratum([0], 1)
else:
return Stratum(
sum(
(
[ZZ(a - 1)] * mult
for a, mult in angles.items()
if marked_points or a != 1
),
[],
),
1,
)
else:
return Stratum(
sum(
(
[ZZ(2 * (a - 1))] * mult
for a, mult in angles.items()
if marked_points or a != 1
),
[],
),
2,
)
[docs]
def billiard_unfolding_stratum_dimension(
self, cover_type="translation", marked_points=False
):
r"""
Return the dimension of the stratum of quadratic or Abelian differential
obtained by unfolding a billiard in a polygon of this equiangular family.
INPUT:
- ``cover_type`` (optional, default ``"translation"``) - either ``"rational"``,
``"half-translation"`` or ``"translation"``
- ``marked_poins`` (optional, default ``False``) - whether the stratum should
have marked regular points
EXAMPLES::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: E = EuclideanPolygonsWithAngles(1, 1, 1)
sage: E.billiard_unfolding_stratum_dimension("half-translation")
2
sage: E.billiard_unfolding_stratum_dimension("translation")
2
sage: E.billiard_unfolding_stratum_dimension("half-translation", True)
4
sage: E.billiard_unfolding_stratum_dimension("translation", True)
4
sage: E = EuclideanPolygonsWithAngles(1, 2, 5)
sage: E.billiard_unfolding_stratum_dimension("half-translation")
4
sage: E.billiard_unfolding_stratum("half-translation").dimension()
4
sage: E.billiard_unfolding_stratum_dimension(cover_type="translation")
6
sage: E.billiard_unfolding_stratum("translation").dimension()
6
sage: E.billiard_unfolding_stratum_dimension("translation", True)
9
sage: E.billiard_unfolding_stratum("translation", True).dimension()
9
sage: E = EuclideanPolygonsWithAngles(1, 3, 5)
sage: E.billiard_unfolding_stratum_dimension("half-translation")
6
sage: E.billiard_unfolding_stratum("half-translation").dimension()
6
sage: E.billiard_unfolding_stratum_dimension("translation")
6
sage: E.billiard_unfolding_stratum("translation").dimension()
6
sage: E = EuclideanPolygonsWithAngles(1, 3, 1, 7)
sage: E.billiard_unfolding_stratum_dimension("half-translation")
6
sage: E = EuclideanPolygonsWithAngles(1, 3, 5, 7)
sage: E.billiard_unfolding_stratum_dimension("half-translation")
8
sage: E = EuclideanPolygonsWithAngles(1, 2, 8)
sage: E.billiard_unfolding_stratum_dimension()
11
sage: E.billiard_unfolding_stratum().dimension()
11
sage: E.billiard_unfolding_stratum_dimension(marked_points=True)
12
sage: E.billiard_unfolding_stratum(marked_points=True).dimension()
12
"""
from sage.all import ZZ
if cover_type == "rational":
raise NotImplementedError
if cover_type != "translation" and cover_type != "half-translation":
raise ValueError
angles = self.billiard_unfolding_angles(cover_type)
if not marked_points:
if 1 in angles:
del angles[1]
if not angles:
angles[ZZ.one()] = ZZ.one()
abelian = all(a.is_integer() for a in angles)
s = sum(angles.values())
chi = sum(mult * (a - 1) for a, mult in angles.items())
assert chi.denominator() == 1
chi = ZZ(chi)
assert chi % 2 == 0
g = chi // 2 + 1
return 2 * g + s - 1 if abelian else 2 * g + s - 2
[docs]
class Simple(CategoryWithAxiom_over_base_ring):
r"""
The subcategory of simple Euclidean polygons with prescribed angles.
EXAMPLES::
sage: from flatsurf.geometry.categories import EuclideanPolygons
sage: EuclideanPolygons(QQ).WithAngles([1, 1, 1, 1]).Simple()
Category of simple euclidean rectangles over Rational Field
"""
# Due to some limitations in SageMath this does not work. Apparently,
# extra_super_categories cannot depend on parameters of the category.
# With this code, some polygons are randomly declared as convex.
# Unfortunately, this means that the category prints as "convex simple
# rectangles" and not just "rectangles".
# def extra_super_categories(self):
# r"""
# Return the categories that simple polygons with prescribed angles
# are additionally contained in; namely, in some cases the category
# of convex polygons.
# EXAMPLES::
# sage: from flatsurf.geometry.categories import EuclideanPolygons
# sage: C = EuclideanPolygons(QQ).Simple().WithAngles([1, 1, 1, 1])
# sage: "Convex" in C.axioms()
# True
# sage: C = EuclideanPolygons(QQ).Simple().WithAngles([2, 2, 1, 6, 1])
# sage: "Convex" in C.axioms()
# False
# """
# # We cannot call is_convex() yet because the SubcategoryMethods
# # have not been established yet.
# if self._base_category.is_convex():
# return (self._base_category.Convex(),)
# return ()
def __call__(self, *lengths, normalized=False, base_ring=None):
r"""
Return a polygon with these angles from ``lengths``.
TESTS::
sage: from flatsurf import EuclideanPolygonsWithAngles
sage: P = EuclideanPolygonsWithAngles(1, 2, 1, 2)
sage: L = P.lengths_polytope()
sage: r0, r1 = [r.vector() for r in L.rays()]
sage: lengths = r0 + r1
sage: P(*lengths[:-2])
doctest:warning
...
UserWarning: calling EuclideanPolygonsWithAngles() has been deprecated and will be removed in a future version of sage-flatsurf; use Polygon(angles=[...], lengths=[...]) instead.
To make the resulting polygon non-normalized, i.e., the lengths are not actual edge lengths but the multiple of slope vectors,
use Polygon(edges=[length * slope for (length, slope) in zip(lengths, EuclideanPolygonsWithAngles(angles).slopes())]).
Polygon(vertices=[(0, 0), (1, 0), (c + 1, 3), (c, 3)])
sage: from flatsurf import Polygon, EuclideanPolygonsWithAngles
sage: P = EuclideanPolygonsWithAngles([1, 2, 1, 2])
sage: Polygon(angles=[1, 2, 1, 2], lengths=lengths[:-2])
Polygon(vertices=[(0, 0), (1, 0), (3/2, 1/2*c), (1/2, 1/2*c)])
sage: Polygon(angles=[1, 2, 1, 2], edges=[length * slope for (length, slope) in zip(lengths[:-2], P.slopes())])
Polygon(vertices=[(0, 0), (1, 0), (c + 1, 3), (c, 3)])
sage: P = EuclideanPolygonsWithAngles(2, 2, 3, 13)
sage: r0, r1 = [r.vector() for r in P.lengths_polytope().rays()]
sage: P(r0 + r1)
Polygon(vertices=[(0, 0), (20, 0), (5, -15*c^3 + 60*c), (5, -5*c^3 + 20*c)])
sage: P = EuclideanPolygonsWithAngles([2, 2, 3, 13])
sage: Polygon(angles=[2, 2, 3, 13], lengths=r0 + r1)
Traceback (most recent call last):
...
ValueError: polygon not closed
sage: Polygon(angles=[2, 2, 3, 13], edges=[length * slope for (length, slope) in zip(r0 + r1, P.slopes())])
Polygon(vertices=[(0, 0), (20, 0), (5, -15*c^3 + 60*c), (5, -5*c^3 + 20*c)])
"""
# __call__() cannot be properly inherited in subcategories since it
# cannot be in SubcategoryMethods; that's why we want to get rid of it.
import warnings
warning = "calling EuclideanPolygonsWithAngles() has been deprecated and will be removed in a future version of sage-flatsurf; use Polygon(angles=[...], lengths=[...]) instead."
if not normalized:
warning += (
" To make the resulting polygon non-normalized, i.e., the lengths are not actual edge lengths but the multiple of slope vectors, use "
"Polygon(edges=[length * slope for (length, slope) in zip(lengths, EuclideanPolygonsWithAngles(angles).slopes())])."
)
warnings.warn(warning)
from sage.structure.element import Vector
if len(lengths) == 1 and isinstance(lengths[0], (tuple, list, Vector)):
lengths = lengths[0]
n = len(self.angles())
if len(lengths) != n - 2 and len(lengths) != n:
raise ValueError(
"must provide %d or %d lengths but provided %d"
% (n - 2, n, len(lengths))
)
V = self.base_ring() ** 2
slopes = self.slopes()
if normalized:
cosines_ring = (
self._without_axiom("Simple")
._without_axiom("Convex")
._cosines_ring()
)
V = V.change_ring(cosines_ring)
for i, s in enumerate(slopes):
x, y = map(cosines_ring, s)
norm2 = (x**2 + y**2).sqrt()
slopes[i] = V((x / norm2, y / norm2))
if base_ring is None:
from sage.all import Sequence
base_ring = Sequence(lengths).universe()
from sage.categories.pushout import pushout
if normalized:
base_ring = pushout(base_ring, cosines_ring)
else:
base_ring = pushout(base_ring, self.base_ring())
v = V((0, 0))
vertices = [v]
from sage.all import vector, matrix
if len(lengths) == n - 2:
for i in range(n - 2):
v += lengths[i] * slopes[i]
vertices.append(v)
s, t = (
vector(vertices[0] - vertices[n - 2])
* matrix([slopes[-1], slopes[n - 2]]).inverse()
)
assert (
vertices[0] - s * slopes[-1] == vertices[n - 2] + t * slopes[n - 2]
)
if s <= 0 or t <= 0:
raise ValueError(
"the provided lengths do not give rise to a polygon"
)
vertices.append(vertices[0] - s * slopes[-1])
elif len(lengths) == n:
for i in range(n):
v += lengths[i] * slopes[i]
vertices.append(v)
if not vertices[-1].is_zero():
raise ValueError(
"the provided lengths do not give rise to a polygon"
)
vertices.pop(-1)
category = self.change_ring(base_ring)
if self.is_convex():
category = category.Convex()
from flatsurf.geometry.polygon import Polygon
return Polygon(base_ring=base_ring, vertices=vertices, category=category)
@cached_function
def _slopes(angles):
r"""
Return the slopes of the sides of a polygon with ``angles`` in a
(possibly non-minimal) number field.
.. NOTE::
This function gets called a lot from the other functions here. We
could refactor things and make sure that the function is only
invoked once. However, it seems easier to just cache its output.
Also, this speeds up the relative common case when multiple
polygons with the same angles are created. (If lots of polygons
with different angles get created then we pay this cache with RAM
of course but in our experiments it has not been an issue.)
.. NOTE::
SageMath 9.1 does not support cached functions that are staticmethods.
Therefore we define this function at the module level.
EXAMPLES::
sage: from flatsurf.geometry.categories.euclidean_polygons_with_angles import _slopes
sage: _slopes((1/6, 1/6, 1/6))
[(c, 3), (c, 3), (c, 3)]
sage: _slopes((1/4, 1/4, 1/4, 1/4))
[(0, 1), (0, 1), (0, 1), (0, 1)]
sage: _slopes((1/10, 2/10, 3/10, 4/10))
[(c^3, 5), (3*c^3 - 10*c, 5), (-3*c^3 + 10*c, 5), (-c^3, 5)]
"""
from sage.all import QQ, RIF, lcm, AA, NumberField
from flatsurf.geometry.subfield import chebyshev_T, cos_minpoly
# We determine the number field that contains the slopes of the sides,
# i.e., the cosines and sines of the inner angles of the polygon.
# Let us first write all angles as multiples of 2π/N with the smallest
# possible common N.
N = lcm(a.denominator() for a in angles)
# The field containing the cosine and sine of 2π/N might be too small
# to write down all the slopes when N is not divisible by 4.
if N == 1:
raise ValueError("there cannot be a polygon with all angles multiples of 2π")
if N == 2:
pass
elif N % 4:
while N % 4:
N *= 2
angles = [QQ(a * N) for a in angles]
if N == 2:
base_ring = QQ
c = QQ.zero()
else:
# Construct the minimal polynomial f(x) of c = 2 cos(2π / N)
f = cos_minpoly(N // 2)
emb = AA.polynomial_root(f, 2 * (2 * RIF.pi() / N).cos())
base_ring = NumberField(f, "c", embedding=emb)
c = base_ring.gen()
# Construct the cosine and sine of each angle as an element of our number field.
def cosine(a):
return chebyshev_T(abs(a), c) / 2
def sine(a):
# Use sin(x) = cos(π/2 - x)
return cosine(N // 4 - a)
slopes = [(cosine(a), sine(a)) for a in angles]
assert all((x**2 + y**2).is_one() for x, y in slopes)
from flatsurf.geometry.euclidean import projectivization
return [projectivization(x, y) for x, y in slopes]
@cached_function
def _base_ring(angles):
r"""
Return a minimal number field containing all the :meth:`_slopes` of a
polygon with ``angles``.
.. NOTE::
Internally, this uses
:func:`~flatsurf.geometry.subfield.subfield_from_element` which is
very slow. We therefore cache the result currently.
.. NOTE::
SageMath 9.1 does not support cached functions that are staticmethods.
Therefore we define this function at the module level.
EXAMPLES::
sage: from flatsurf.geometry.categories.euclidean_polygons_with_angles import _base_ring
sage: _base_ring((1/6, 1/6, 1/6))
Number Field in c with defining polynomial x^2 - 3 with c = 1.732050807568878?
sage: _base_ring((1/4, 1/4, 1/4, 1/4))
Rational Field
sage: _base_ring((1/10, 2/10, 3/10, 4/10))
Number Field in c with defining polynomial x^4 - 5*x^2 + 5 with c = 1.902113032590308?
"""
slopes = _slopes(angles)
base_ring = slopes[0][0].parent()
# It might be the case that the slopes generate a smaller field. For
# now we use an ugly workaround via subfield_from_elements.
old_slopes = []
for v in slopes:
old_slopes.extend(v)
from flatsurf.geometry.subfield import subfield_from_elements
L, _, _ = subfield_from_elements(base_ring, old_slopes)
return L