passagemath-polyhedra 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage/geometry/polyhedron/palp_database.py

@@ -0,0 +1,447 @@
+# sage_setup: distribution = sagemath-polyhedra
+# sage.doctest: optional - polytopes_db palp
+"""
+Access the PALP database(s) of reflexive lattice polytopes
+
+EXAMPLES::
+
+    sage: from sage.geometry.polyhedron.palp_database import PALPreader
+    sage: for lp in PALPreader(2):                                                      # needs fpylll sage.graphs sage.libs.singular
+    ....:     cone = Cone([(1,r[0],r[1]) for r in lp.vertices()])
+    ....:     fan = Fan([cone])
+    ....:     X = ToricVariety(fan)
+    ....:     ideal = X.affine_algebraic_patch(cone).defining_ideal()
+    ....:     print("{} {}".format(lp.n_vertices(), ideal.hilbert_series()))
+    3 (t^2 + 7*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    3 (t^2 + t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    3 (t^2 + 6*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    3 (t^2 + 2*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    3 (t^2 + 4*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 5*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 3*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 2*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 6*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 6*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 2*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    4 (t^2 + 4*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    5 (t^2 + 3*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    5 (t^2 + 5*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    5 (t^2 + 4*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+    6 (t^2 + 4*t + 1)/(-t^3 + 3*t^2 - 3*t + 1)
+"""
+
+import os
+
+from subprocess import Popen, PIPE
+
+from sage.structure.sage_object import SageObject
+from sage.rings.integer_ring import ZZ
+from sage.features.palp import PalpExecutable
+from sage.features.databases import DatabaseReflexivePolytopes
+
+from sage.interfaces.process import terminate
+
+from sage.geometry.polyhedron.ppl_lattice_polytope import LatticePolytope_PPL
+
+
+#########################################################################
+class PALPreader(SageObject):
+    """
+    Read PALP database of polytopes.
+
+    INPUT:
+
+    - ``dim`` -- integer; the dimension of the polyhedra
+
+    - ``data_basename`` -- string or ``None`` (default). The directory
+      and database base filename (PALP usually uses ``'zzdb'``) name
+      containing the PALP database to read. Defaults to the built-in
+      database location.
+
+    - ``output`` -- string. How to return the reflexive polyhedron
+      data. Allowed values = ``'list'``, ``'Polyhedron'`` (default),
+      ``'pointcollection'``, and ``'PPL'``. Case is ignored.
+
+    EXAMPLES::
+
+        sage: from sage.geometry.polyhedron.palp_database import PALPreader
+        sage: polygons = PALPreader(2)
+        sage: [ (p.n_Vrepresentation(), len(p.integral_points())) for p in polygons ]
+        [(3, 4), (3, 10), (3, 5), (3, 9), (3, 7), (4, 6), (4, 8), (4, 9),
+         (4, 5), (4, 5), (4, 9), (4, 7), (5, 8), (5, 6), (5, 7), (6, 7)]
+
+        sage: next(iter(PALPreader(2, output='list')))
+        [[1, 0], [0, 1], [-1, -1]]
+        sage: type(_)
+        <... 'list'>
+
+        sage: next(iter(PALPreader(2, output='Polyhedron')))
+        A 2-dimensional polyhedron in ZZ^2 defined as the convex hull of 3 vertices
+        sage: type(_)
+        <class 'sage.geometry.polyhedron.parent.Polyhedra_ZZ_ppl_with_category.element_class'>
+
+        sage: next(iter(PALPreader(2, output='PPL')))
+        A 2-dimensional lattice polytope in ZZ^2 with 3 vertices
+        sage: type(_)
+        <class 'sage.geometry.polyhedron.ppl_lattice_polygon.LatticePolygon_PPL_class'>
+
+        sage: next(iter(PALPreader(2, output='PointCollection')))
+        [ 1,  0],
+        [ 0,  1],
+        [-1, -1]
+        in Ambient free module of rank 2 over the principal ideal domain Integer Ring
+        sage: type(_)
+        <class 'sage.geometry.point_collection.PointCollection'>
+    """
+
+    def __init__(self, dim, data_basename=None, output='Polyhedron'):
+        """
+        The Python constructor.
+
+        See :class:`PALPreader` for documentation.
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+        """
+        self._dim = dim
+        if data_basename is not None:
+            self._data_basename = data_basename
+        else:
+            db = DatabaseReflexivePolytopes()
+            self._data_basename = os.path.join(
+                    os.path.dirname(db.absolute_filename()),
+                    f'Full{dim}d', 'zzdb')
+            info = self._data_basename + '.info'
+            if not os.path.exists(info):
+                raise ValueError('Cannot find PALP database: {}'.format(info))
+
+        from sage.geometry.polyhedron.parent import Polyhedra
+        self._polyhedron_parent = Polyhedra(ZZ, dim)
+        self._output = output.lower()
+
+    def _palp_Popen(self):
+        """
+        Open PALP.
+
+        OUTPUT: a PALP subprocess
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: polygons._palp_Popen()
+            <...Popen...>
+        """
+
+        return Popen([PalpExecutable("class").absolute_filename(), "-b2a", "-di", self._data_basename],
+                     stdout=PIPE, encoding='utf-8', errors='surrogateescape')
+
+    def _read_vertices(self, stdout, rows, cols):
+        r"""
+        Read vertex data from the PALP output pipe.
+
+        OUTPUT: list of lists
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: palp = polygons._palp_Popen()
+            sage: palp.stdout.readline()
+            '2 3  \n'
+            sage: polygons._read_vertices(palp.stdout, 2, 3)
+            [[1, 0], [0, 1], [-1, -1]]
+        """
+        m = [[] for col in range(cols)]
+        for row in range(rows):
+            for col, x in enumerate(stdout.readline().split()):
+                m[col].append(ZZ(x))
+        return m
+
+    def _read_vertices_transposed(self, stdout, rows, cols):
+        r"""
+        Read vertex data from the PALP output pipe.
+
+        OUTPUT: list of lists
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: palp = polygons._palp_Popen()
+            sage: palp.stdout.readline()
+            '2 3  \n'
+            sage: polygons._read_vertices_transposed(palp.stdout, 2, 3)
+            [[1, 0, -1], [0, 1, -1]]
+        """
+        m = []
+        for row in range(rows):
+            m.append([ZZ(x) for x in stdout.readline().split()])
+        return m
+
+    def _iterate_list(self, start, stop, step):
+        """
+        Iterate over the reflexive polytopes.
+
+        INPUT:
+
+        - ``start``, ``stop``, ``step`` -- integers specifying the
+          range to iterate over
+
+        OUTPUT: a generator for vertex data as a list of lists
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: iter = polygons._iterate_list(0,4,2)
+            sage: next(iter)
+            [[1, 0], [0, 1], [-1, -1]]
+        """
+        if start is None:
+            start = 0
+        if step is None:
+            step = 1
+        palp = self._palp_Popen()
+        with terminate(palp):
+            palp_out = palp.stdout
+            i = 0
+            while True:
+                l = palp_out.readline().strip()
+                if l == '' or l.startswith('#'):
+                    return  # EOF
+                l = l.split()
+                dim = ZZ(l[0])  # dimension
+                n = ZZ(l[1])    # number of vertices
+                if i >= start and (i - start) % step == 0:
+                    if dim == self._dim:
+                        vertices = self._read_vertices(palp_out, dim, n)
+                    elif n == self._dim:
+                        # PALP sometimes returns transposed data #@!#@
+                        vertices = self._read_vertices_transposed(palp_out, dim, n)
+                    else:
+                        raise ValueError('PALP output dimension mismatch.')
+                    yield vertices
+                else:
+                    for row in range(dim):
+                        palp_out.readline()
+                i += 1
+                if stop is not None and i >= stop:
+                    return
+
+    def _iterate_Polyhedron(self, start, stop, step):
+        """
+        Iterate over the reflexive polytopes.
+
+        INPUT:
+
+        - ``start``, ``stop``, ``step`` -- integers specifying the
+          range to iterate over
+
+        OUTPUT: a generator for lattice polyhedra
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: iter = polygons._iterate_Polyhedron(0,4,2)
+            sage: next(iter)
+            A 2-dimensional polyhedron in ZZ^2 defined as the convex hull of 3 vertices
+        """
+        parent = self._polyhedron_parent
+        for vertices in self._iterate_list(start, stop, step):
+            p = parent.element_class(parent, [vertices, [], []], None)
+            yield p
+
+    def _iterate_PPL(self, start, stop, step):
+        """
+        Iterate over the reflexive polytopes.
+
+        INPUT:
+
+        - ``start``, ``stop``, ``step`` -- integers specifying the
+          range to iterate over
+
+        OUTPUT: a generator for PPL-based lattice polyhedra
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: iter = polygons._iterate_PPL(0,4,2)
+            sage: next(iter)
+            A 2-dimensional lattice polytope in ZZ^2 with 3 vertices
+        """
+        for vertices in self._iterate_list(start, stop, step):
+            yield LatticePolytope_PPL(*vertices)
+
+    def _iterate_PointCollection(self, start, stop, step):
+        """
+        Iterate over the reflexive polytopes.
+
+        INPUT:
+
+        - ``start``, ``stop``, ``step`` -- integers specifying the
+          range to iterate over
+
+        OUTPUT: a generator for PPL-based lattice polyhedra
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: iter = polygons._iterate_PointCollection(0,4,2)
+            sage: next(iter)
+            [ 1,  0],
+            [ 0,  1],
+            [-1, -1]
+            in Ambient free module of rank 2 over the principal ideal domain Integer Ring
+        """
+        from sage.modules.free_module import FreeModule
+        from sage.geometry.point_collection import PointCollection
+
+        N = FreeModule(ZZ, self._dim)
+        for vertices in self._iterate_list(start, stop, step):
+            yield PointCollection(vertices, module=N)
+
+    def _iterate(self, output=None):
+        """
+        Iterate over the reflexive polytopes.
+
+        INPUT:
+
+        - ``output`` -- as in the :class:`PALPreader` constructor
+
+        OUTPUT: a function generating lattice polytopes in the specified output format
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: func = polygons._iterate(output='list')
+            sage: func
+            <bound method PALPreader._iterate_list of <sage.geometry.polyhedron.palp_database.PALPreader object at ...>>
+            sage: iter = func(0,1,1)
+            sage: next(iter)
+            [[1, 0], [0, 1], [-1, -1]]
+        """
+        if output is None:
+            output = self._output
+        if output == 'polyhedron':
+            return self._iterate_Polyhedron
+        elif output == 'ppl':
+            return self._iterate_PPL
+        elif output == 'pointcollection':
+            return self._iterate_PointCollection
+        elif output == 'list':
+            return self._iterate_list
+        else:
+            raise TypeError('Unknown output format (={}).'.format(self._output))
+
+    def __iter__(self):
+        """
+        Iterate over all polytopes.
+
+        OUTPUT: an iterator for all polytopes
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: polygons = PALPreader(2)
+            sage: polygons.__iter__()
+            <generator object ..._iterate_Polyhedron at 0x...>
+        """
+        iterator = self._iterate()
+        return iterator(None, None, None)
+
+    def __getitem__(self, item):
+        """
+        Return the polytopes(s) indexed by ``item``.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import PALPreader
+            sage: palp = PALPreader(3)
+            sage: list(palp[10:30:10])
+            [A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 4 vertices,
+             A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 4 vertices]
+        """
+        iterator = self._iterate()
+        if isinstance(item, slice):
+            return iterator(item.start, item.stop, item.step)
+        else:
+            try:
+                return next(iterator(item, item + 1, 1))
+            except StopIteration:
+                raise IndexError('Index out of range.')
+
+
+class Reflexive4dHodge(PALPreader):
+    """
+    Read the PALP database for Hodge numbers of 4d polytopes.
+
+    The database is very large and not installed by default. You can
+    install it with the shell command ``sage -i polytopes_db_4d``.
+
+    INPUT:
+
+    - ``h11``, ``h21`` -- integer; the Hodge numbers of the reflexive
+      polytopes to list
+
+    Any additional keyword arguments are passed to
+    :class:`PALPreader`.
+
+    EXAMPLES::
+
+        sage: from sage.geometry.polyhedron.palp_database import Reflexive4dHodge
+        sage: ref = Reflexive4dHodge(1,101)             # optional - polytopes_db_4d
+        sage: next(iter(ref)).Vrepresentation()         # optional - polytopes_db_4d
+        (A vertex at (-1, -1, -1, -1), A vertex at (0, 0, 0, 1),
+         A vertex at (0, 0, 1, 0), A vertex at (0, 1, 0, 0), A vertex at (1, 0, 0, 0))
+    """
+    def __init__(self, h11, h21, data_basename=None, **kwds):
+        """
+        The Python constructor.
+
+        See :class:`Reflexive4dHodge` for documentation.
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.palp_database import Reflexive4dHodge
+            sage: Reflexive4dHodge(1,101)  # optional - polytopes_db_4d
+            <sage.geometry.polyhedron.palp_database.Reflexive4dHodge object at ...>
+        """
+        dim = 4
+        if data_basename is None:
+            db = DatabaseReflexivePolytopes('polytopes_db_4d')
+            data_basename = os.path.join(db.absolute_filename(), 'all')
+            info = data_basename + '.vinfo'
+            if not os.path.exists(info):
+                raise ValueError(
+                    'Cannot find PALP database: {}. Did you install the '
+                    'polytopes_db_4d optional spkg?'.format(info))
+
+        PALPreader.__init__(self, dim, data_basename=data_basename, **kwds)
+        self._h11 = h11
+        self._h21 = h21
+
+    def _palp_Popen(self):
+        """
+        Open PALP.
+
+        OUTPUT: a PALP subprocess
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.palp_database import Reflexive4dHodge
+            sage: polygons = Reflexive4dHodge(1, 101)   # optional - polytopes_db_4d
+            sage: polygons._palp_Popen()                # optional - polytopes_db_4d
+            <...Popen...>
+        """
+
+        return Popen([PalpExecutable('class-4d').absolute_filename(), '-He',
+                      'H{}:{}L100000000'.format(self._h21, self._h11),
+                      '-di', self._data_basename], stdout=PIPE,
+                     encoding='utf-8', errors='surrogateescape')