passagemath-polyhedra 10.6.31rc3__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

sage/geometry/polyhedron/base_mutable.py

@@ -0,0 +1,215 @@
+# sage_setup: distribution = sagemath-polyhedra
+r"""
+Base class for mutable polyhedra.
+
+Just like vectors and matrices they can be set immutable.
+The constructor does this by default.
+"""
+
+from sage.misc.abstract_method import abstract_method
+
+from .base import Polyhedron_base
+
+
+class Polyhedron_mutable(Polyhedron_base):
+    """
+    Base class for polyhedra that allow mutability.
+
+    This should not be used directly.
+    """
+
+    def __hash__(self):
+        r"""
+        TESTS::
+
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: set([p])
+            Traceback (most recent call last):
+            ...
+            TypeError: ...mutable polyhedra are unhashable...
+            sage: p.set_immutable()
+            sage: set([p])
+            {A 0-dimensional polyhedron in ZZ^2 defined as the convex hull of 1 vertex}
+        """
+        if self._is_mutable:
+            raise TypeError("mutable polyhedra are unhashable")
+        return Polyhedron_base.__hash__(self)
+
+    def _clear_cache(self):
+        r"""
+        Clear the Vrepresentation and Hrepresentation data of ``self``.
+
+        TESTS::
+
+            sage: p = polytopes.permutahedron(4)
+            sage: P = p.parent()
+            sage: q = P._element_constructor_(p, mutable=True)
+            sage: TestSuite(q).run()                                                    # needs sage.libs.pari
+            sage: q._clear_cache()
+            sage: TestSuite(q).run()                                                    # needs sage.libs.pari
+
+        ::
+
+            sage: q.set_immutable()
+            sage: q._clear_cache()
+            Traceback (most recent call last):
+            ...
+            TypeError: cannot clear cache of immutable polyhedra
+        """
+        if not self._is_mutable:
+            raise TypeError("cannot clear cache of immutable polyhedra")
+
+        # Invalidate object pointing towards this polyhedron (faces etc.).
+        for ob in self._dependent_objects:
+            ob._polyhedron = None
+        backend_object = self.__dict__["_" + self._backend_object_name]
+        del self.__dict__
+        self.__dict__["_" + self._backend_object_name] = backend_object
+        self._is_mutable = True
+        self._dependent_objects = []
+
+    def _add_dependent_object(self, ob):
+        r"""
+        Add an object that has ``self`` has attribute ``_polyhedron``.
+
+        When ``self`` is modified, we delete this attribute to invalidate those objects.
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: class foo:
+            ....:     def __init__(self, p):
+            ....:         self._polyhedron = p
+            ....:
+            sage: a = foo(p)
+            sage: a.__dict__
+            {'_polyhedron': A 0-dimensional polyhedron in ZZ^2 defined as the convex hull of 1 vertex}
+            sage: p._add_dependent_object(a)
+            sage: p._clear_cache()
+            sage: a.__dict__
+            {'_polyhedron': None}
+
+        TESTS::
+
+            sage: from sage.geometry.newton_polygon import NewtonPolygon
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: n = NewtonPolygon(p)
+            sage: n
+            Finite Newton polygon with 1 vertex: (1, 1)
+            sage: n = NewtonPolygon(p)
+            sage: p._clear_cache()
+            sage: n
+            <repr(<sage.geometry.newton_polygon.ParentNewtonPolygon_with_category.element_class at ...>) failed: AttributeError: 'NoneType' object has no attribute 'vertices'>
+
+        ::
+
+            sage: f = p.faces(0)[0]; f
+            A 0-dimensional face of a Polyhedron in ZZ^2 defined as the convex hull of 1 vertex
+            sage: p._clear_cache()
+            sage: f
+            <repr(<sage.geometry.polyhedron.face.PolyhedronFace at ...>) failed: AttributeError: 'NoneType' object has no attribute 'parent'>
+
+        ::
+
+            sage: v = p.vertices()[0]
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: v = p.Vrepresentation(0); v
+            A vertex at (1, 1)
+            sage: h = p.Hrepresentation(0); h
+            An equation (0, 1) x - 1 == 0
+            sage: p._clear_cache()
+            sage: v.polyhedron() is None
+            True
+            sage: h.polyhedron() is None
+            True
+
+        ::
+
+            sage: p = Polyhedron([[1, 0], [0, 1]], mutable=True)
+            sage: r = p.relative_interior()
+            sage: p._clear_cache()
+            sage: r
+            Relative interior of None
+        """
+        if ob._polyhedron is not self:
+            raise ValueError
+        self._dependent_objects.append(ob)
+
+    def is_mutable(self):
+        r"""
+        Return ``True`` if the polyhedron is mutable, i.e. it can be modified in place.
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: p.is_mutable()
+            True
+            sage: p = Polyhedron([[1, 1]], mutable=False)
+            sage: p.is_mutable()
+            False
+        """
+        return self._is_mutable
+
+    def is_immutable(self):
+        r"""
+        Return ``True`` if the polyhedron is immutable, i.e. it cannot be modified in place.
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([[1, 1]], mutable=True)
+            sage: p.is_immutable()
+            False
+            sage: p = Polyhedron([[1, 1]], mutable=False)
+            sage: p.is_immutable()
+            True
+        """
+        return not self._is_mutable
+
+    @abstract_method
+    def set_immutable(self):
+        r"""
+        Make this polyhedron immutable. This operation cannot be undone.
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.base_mutable import Polyhedron_mutable
+            sage: p = polytopes.cube()
+            sage: Polyhedron_mutable.set_immutable(p)
+            Traceback (most recent call last):
+            ...
+            TypeError: 'AbstractMethod' object is not callable
+        """
+
+    @abstract_method
+    def Vrepresentation(self):
+        r"""
+        A derived class must overwrite such that it restores Vrepresentation
+        after clearing it.
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.base_mutable import Polyhedron_mutable
+            sage: p = polytopes.cube()
+            sage: Polyhedron_mutable.Vrepresentation(p)
+            Traceback (most recent call last):
+            ...
+            TypeError: 'AbstractMethod' object is not callable
+        """
+        # A derived class must implemented it to recalculate, if necessary.
+
+    @abstract_method
+    def Hrepresentation(self):
+        r"""
+        A derived class must overwrite such that it restores Hrepresentation
+        after clearing it.
+
+        TESTS::
+
+            sage: from sage.geometry.polyhedron.base_mutable import Polyhedron_mutable
+            sage: p = polytopes.cube()
+            sage: Polyhedron_mutable.Hrepresentation(p)
+            Traceback (most recent call last):
+            ...
+            TypeError: 'AbstractMethod' object is not callable
+        """
+        # A derived class must implemented it to recalculate, if necessary.

sage/geometry/polyhedron/base_number_field.py

@@ -0,0 +1,122 @@
+# sage_setup: distribution = sagemath-polyhedra
+r"""
+Support for internal use of number fields in backends for polyhedral computations
+"""
+
+# ****************************************************************************
+#  Copyright (C) 2016-2022 Matthias Köppe <mkoeppe at math.ucdavis.edu>
+#                2016-2018 Travis Scrimshaw
+#                2017      Jeroen Demeyer
+#                2018-2020 Jean-Philippe Labbé
+#                2019      Vincent Delecroix
+#                2019-2021 Jonathan Kliem
+#                2019-2021 Sophia Elia
+#                2020      Frédéric Chapoton
+#                2022      Yuan Zhou
+#
+# This program 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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.rings.integer_ring import ZZ
+from sage.rings.rational_field import QQ
+
+from .base import Polyhedron_base
+
+
+def _number_field_elements_from_algebraics_list_of_lists_of_lists(listss, **kwds):
+    r"""
+    Like ``number_field_elements_from_algebraics``, but for a list of lists of lists.
+
+    EXAMPLES::
+
+        sage: rt2 = AA(sqrt(2)); rt2                                                    # needs sage.rings.number_field sage.symbolic
+        1.414213562373095?
+        sage: rt3 = AA(sqrt(3)); rt3                                                    # needs sage.rings.number_field sage.symbolic
+        1.732050807568878?
+        sage: from sage.geometry.polyhedron.base_number_field import _number_field_elements_from_algebraics_list_of_lists_of_lists
+        sage: K, results, hom = _number_field_elements_from_algebraics_list_of_lists_of_lists([[[rt2], [1]], [[rt3]], [[1], []]]); results                      # needs sage.rings.number_field sage.symbolic
+        [[[-a^3 + 3*a], [1]], [[a^2 - 2]], [[1], []]]
+    """
+    from sage.rings.qqbar import number_field_elements_from_algebraics
+    numbers = []
+    for lists in listss:
+        for list in lists:
+            numbers.extend(list)
+    K, K_numbers, hom = number_field_elements_from_algebraics(numbers, **kwds)
+    g = iter(K_numbers)
+    return K, [ [ [ next(g) for _ in list ] for list in lists ] for lists in listss ], hom
+
+
+class Polyhedron_base_number_field(Polyhedron_base):
+
+    def _compute_data_lists_and_internal_base_ring(self, data_lists, convert_QQ, convert_NF):
+        r"""
+        Compute data lists in Normaliz or ``number_field`` backend format and the internal base ring of the data.
+
+        EXAMPLES::
+
+            sage: # optional - pynormaliz, needs sage.rings.number_field
+            sage: p = Polyhedron(vertices=[(0,1/2), (2,0), (4,5/6)],
+            ....:                base_ring=AA, backend='normaliz')
+            sage: def convert_QQ(ieqs, eqs):
+            ....:     return [[1000*x for x in ieq] for ieq in ieqs], \
+            ....:            [[1000*x for x in eq] for eq in eqs]
+            sage: def convert_NF(ieqs, eqs):
+            ....:     return ieqs, eqs
+            sage: p._compute_data_lists_and_internal_base_ring(
+            ....:     [[[1]], [[1/2]]], convert_QQ, convert_NF)
+            (([[1000]], [[500]]), Rational Field)
+            sage: p._compute_data_lists_and_internal_base_ring(
+            ....:     [[[AA(1)]], [[1/2]]], convert_QQ, convert_NF)
+            (([[1000]], [[500]]), Rational Field)
+            sage: p._compute_data_lists_and_internal_base_ring(
+            ....:     [[[AA(sqrt(2))]], [[1/2]]], convert_QQ, convert_NF)
+            ([[[a]], [[1/2]]],
+             Number Field in a with defining polynomial y^2 - 2 with a = 1.414213562373095?)
+
+        TESTS::
+
+            sage: K.<a> = QuadraticField(-5)                                            # needs sage.rings.number_field
+            sage: p = Polyhedron(base_ring=K,       # indirect doctest  # optional - pynormaliz, needs sage.rings.number_field
+            ....:                backend='normaliz',
+            ....:                vertices=[(a,1/2), (2,0), (4,5/6)])
+            Traceback (most recent call last):
+            ...
+            ValueError: invalid base ring: Number Field in a ... is not real embedded
+
+        Checks that :issue:`30248` is fixed::
+
+            sage: q = Polyhedron(base_ring=AA,      # indirect doctest  # optional - pynormaliz, needs sage.rings.number_field
+            ....:                backend='normaliz',
+            ....:                rays=[(0, 0, 1), (0, 1, -1), (1, 0, -1)]); q
+            A 3-dimensional polyhedron in AA^3 defined as the convex hull of 1 vertex and 3 rays
+            sage: -q                                                    # optional - pynormaliz, needs sage.rings.number_field
+            A 3-dimensional polyhedron in AA^3 defined as the convex hull of 1 vertex and 3 rays
+        """
+        from sage.categories.number_fields import NumberFields
+        from sage.rings.real_double import RDF
+
+        if self.base_ring() in (QQ, ZZ):
+            internal_base_ring = QQ
+            internal_data_lists = convert_QQ(*data_lists)
+        else:
+            # Allows to re-iterate if K is QQ below when data_lists contain
+            # iterators:
+            data_lists = [tuple(_) for _ in data_lists]
+            internal_data_lists = convert_NF(*data_lists)
+            if self.base_ring() in NumberFields():
+                if not RDF.has_coerce_map_from(self.base_ring()):
+                    raise ValueError("invalid base ring: {} is a number field that is not real embedded".format(self.base_ring()))
+                internal_base_ring = self.base_ring()
+            else:
+                K, internal_data_lists, hom = _number_field_elements_from_algebraics_list_of_lists_of_lists(internal_data_lists, embedded=True)
+                internal_base_ring = K
+                if K is QQ:
+                    # Compute it with Normaliz, not QNormaliz
+                    internal_data_lists = convert_QQ(*[ [ [ QQ(x) for x in v ] for v in l]
+                                                   for l in data_lists ])
+        return internal_data_lists, internal_base_ring

sage/geometry/polyhedron/cdd_file_format.py

@@ -0,0 +1,155 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+Generate cdd ``.ext`` / ``.ine`` file format
+"""
+
+########################################################################
+#       Copyright (C) 2008 Marshall Hampton <hamptonio@gmail.com>
+#       Copyright (C) 2011 Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  http://www.gnu.org/licenses/
+########################################################################
+
+from .misc import _set_to_None_if_empty, _common_length_of, _to_space_separated_string
+
+#########################################################################
+
+
+def cdd_Vrepresentation(cdd_type, vertices, rays, lines, file_output=None):
+    r"""
+    Return a string containing the V-representation in cddlib's ext format.
+
+    INPUT:
+
+    - ``file_output`` -- string (optional); a filename to which the
+      representation should be written. If set to ``None`` (default),
+      representation is returned as a string.
+
+    .. NOTE::
+
+        If there is no vertex given, then the origin will be implicitly
+        added. You cannot write the empty V-representation (which cdd would
+        refuse to process).
+
+    EXAMPLES::
+
+        sage: from sage.geometry.polyhedron.cdd_file_format import cdd_Vrepresentation
+        sage: print(cdd_Vrepresentation('rational', [[0,0]], [[1,0]], [[0,1]]))
+        V-representation
+        linearity 1 1
+        begin
+          3 3 rational
+          0 0 1
+          0 1 0
+          1 0 0
+        end
+
+    TESTS::
+
+        sage: from sage.misc.temporary_file import tmp_filename
+        sage: filename = tmp_filename(ext='.ext')
+        sage: cdd_Vrepresentation('rational', [[0,0]], [[1,0]], [[0,1]], file_output=filename)
+    """
+    vertices = _set_to_None_if_empty(vertices)
+    rays = _set_to_None_if_empty(rays)
+    lines = _set_to_None_if_empty(lines)
+
+    num, ambient_dim = _common_length_of(vertices, rays, lines)
+
+    # cdd implicitly assumes that the origin is a vertex if none is given
+    if vertices is None:
+        vertices = [[0]*ambient_dim]
+        num += 1
+
+    if cdd_type == 'real':
+        from sage.rings.real_double import RDF
+        base_ring = RDF
+    else:
+        base_ring = None
+
+    s = 'V-representation\n'
+    if lines is not None:
+        n = len(lines)
+        s += "linearity " + repr(n) + ' '
+        s += _to_space_separated_string(range(1,n+1)) + '\n'
+    s += 'begin\n'
+    s += ' ' + repr(num) + ' ' + repr(ambient_dim+1) + ' ' + cdd_type + '\n'
+    if lines is not None:
+        for l in lines:
+            s += ' 0 ' + _to_space_separated_string(l, base_ring) + '\n'
+    if rays is not None:
+        for r in rays:
+            s += ' 0 ' + _to_space_separated_string(r, base_ring) + '\n'
+    if vertices is not None:
+        for v in vertices:
+            s += ' 1 ' + _to_space_separated_string(v, base_ring) + '\n'
+    s += 'end\n'
+
+    if file_output is not None:
+        in_file = open(file_output, 'w')
+        in_file.write(s)
+        in_file.close()
+    else:
+        return s
+
+#########################################################################
+
+
+def cdd_Hrepresentation(cdd_type, ieqs, eqns, file_output=None):
+    r"""
+    Return a string containing the H-representation in cddlib's ine format.
+
+    INPUT:
+
+    - ``file_output`` -- string (optional); a filename to which the
+      representation should be written. If set to ``None`` (default),
+      representation is returned as a string.
+
+    EXAMPLES::
+
+        sage: from sage.geometry.polyhedron.cdd_file_format import cdd_Hrepresentation
+        sage: cdd_Hrepresentation('rational', None, [[0,1]])
+        'H-representation\nlinearity 1 1\nbegin\n 1 2 rational\n 0 1\nend\n'
+
+    TESTS::
+
+        sage: from sage.misc.temporary_file import tmp_filename
+        sage: filename = tmp_filename(ext='.ine')
+        sage: cdd_Hrepresentation('rational', None, [[0,1]], file_output=filename)
+    """
+    ieqs = _set_to_None_if_empty(ieqs)
+    eqns = _set_to_None_if_empty(eqns)
+
+    num, ambient_dim = _common_length_of(ieqs, eqns)
+    ambient_dim -= 1
+
+    if cdd_type == 'real':
+        from sage.rings.real_double import RDF
+        base_ring = RDF
+    else:
+        base_ring = None
+
+    s = 'H-representation\n'
+    if eqns is not None:
+        assert len(eqns) > 0
+        n = len(eqns)
+        s += "linearity " + repr(n) + ' '
+        s += _to_space_separated_string(range(1,n+1)) + '\n'
+    s += 'begin\n'
+    s += ' ' + repr(num) + ' ' + repr(ambient_dim+1) + ' ' + cdd_type + '\n'
+    if eqns is not None:
+        for e in eqns:
+            s += ' ' + _to_space_separated_string(e, base_ring) + '\n'
+    if ieqs is not None:
+        for i in ieqs:
+            s += ' ' + _to_space_separated_string(i, base_ring) + '\n'
+    s += 'end\n'
+
+    if file_output is not None:
+        in_file = open(file_output, 'w')
+        in_file.write(s)
+        in_file.close()
+    else:
+        return s

sage/geometry/polyhedron/combinatorial_polyhedron/all.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-polyhedra

sage/geometry/polyhedron/combinatorial_polyhedron/base.pxd

@@ -0,0 +1,76 @@
+# sage_setup: distribution = sagemath-polyhedra
+cimport cython
+from sage.data_structures.list_of_pairs cimport ListOfPairs
+from sage.structure.sage_object         cimport SageObject
+from sage.geometry.polyhedron.combinatorial_polyhedron.face_iterator                     cimport FaceIterator, CombinatorialFace
+from sage.geometry.polyhedron.combinatorial_polyhedron.list_of_faces                     cimport ListOfFaces
+from sage.geometry.polyhedron.combinatorial_polyhedron.face_data_structure               cimport face_t
+from sage.geometry.polyhedron.combinatorial_polyhedron.polyhedron_face_lattice           cimport PolyhedronFaceLattice
+
+
+@cython.final
+cdef class CombinatorialPolyhedron(SageObject):
+    cdef public dict _cached_methods
+
+    # Do not assume any of those attributes to be initialized, use the corresponding methods instead.
+    cdef tuple _Vrep                       # the names of VRep, if they exist
+    cdef tuple _facet_names                # the names of HRep without equations, if they exist
+    cdef tuple _equations                  # stores equations, given on input (might belong to Hrep)
+    cdef int _dimension                    # stores dimension, -2 on init
+    cdef unsigned int _n_Hrepresentation   # Hrep might include equations
+    cdef unsigned int _n_Vrepresentation   # Vrep might include rays/lines
+    cdef size_t _n_facets                  # length Hrep without equations
+    cdef bint _bounded                     # ``True`` iff Polyhedron is bounded
+    cdef ListOfFaces _bitrep_facets        # facets in bit representation
+    cdef ListOfFaces _bitrep_Vrep          # vertices in bit representation
+    cdef face_t _far_face                  # a 'face' containing all none-vertices of Vrep
+    cdef tuple _far_face_tuple
+    cdef tuple _f_vector
+
+    cdef ListOfPairs _edges                    # stores edges labeled by vertex indices
+    cdef ListOfPairs _ridges                   # stores ridges labeled by facet indices
+    cdef ListOfPairs _face_lattice_incidences  # stores incidences in Hasse diagram labeled indices of the faces
+    cdef PolyhedronFaceLattice _all_faces     # class to generate Hasse diagram incidences
+
+    cdef tuple Vrep(self)
+    cdef tuple facet_names(self)
+    cdef tuple equations(self)
+    cdef unsigned int n_Vrepresentation(self) noexcept
+    cdef unsigned int n_Hrepresentation(self) noexcept
+    cdef bint is_bounded(self) noexcept
+    cdef ListOfFaces bitrep_facets(self)
+    cdef ListOfFaces bitrep_Vrep(self)
+    cdef tuple far_face_tuple(self)
+    cdef int _algorithm_to_dual(self, algorithm) except -2
+
+    # Methods to initialize the combinatorial polyhedron.
+    cdef _init_from_polyhedron(self, data)
+    cdef _init_from_lattice_polytope(self, data)
+    cdef _init_from_cone(self, data)
+    cdef _init_facet_names(self, facets)
+    cdef _init_from_incidence_matrix(self, data)
+    cdef _init_from_list_of_facets(self, data)
+    cdef _init_from_ListOfFaces(self, ListOfFaces facets, ListOfFaces Vrep)
+    cdef _initialize_far_face(self)
+    cdef _init_as_trivial_polyhedron(self, int dimension)
+
+    # Methods to obtain a different combinatorial polyhedron.
+    cpdef CombinatorialPolyhedron dual(self)
+    cpdef CombinatorialPolyhedron pyramid(self, new_vertex=*, new_facet=*)
+
+    cdef FaceIterator _face_iter(self, bint dual, int dimension)
+    cdef int _compute_f_vector(self, size_t num_threads, size_t parallelization_depth, int dual) except -1
+    cdef int _persist_f_vector(self, size_t* input_f_vector, bint input_is_reversed) except -1
+
+    cdef inline int _compute_edges(self, dual) except -1:
+        return self._compute_edges_or_ridges(dual, True)
+
+    cdef inline int _compute_ridges(self, dual) except -1:
+        return self._compute_edges_or_ridges(dual, False)
+
+    cdef int _compute_edges_or_ridges(self, int dual, bint do_edges) except -1
+    cdef size_t _compute_edges_or_ridges_with_iterator(
+            self, FaceIterator face_iter, const bint do_atom_rep,
+            ListOfPairs edges, size_t* f_vector) except -1
+
+    cdef int _compute_face_lattice_incidences(self) except -1