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

sage/geometry/polyhedron/backend_cdd_rdf.py

@@ -0,0 +1,231 @@
+# sage_setup: distribution = sagemath-polyhedra
+# sage.doctest: needs cddexec_gmp sage.rings.real_double
+
+r"""
+The cdd backend for polyhedral computations, floating point version
+"""
+# ****************************************************************************
+#       Copyright (C) 2011-2014 Volker Braun <vbraun.name@gmail.com>
+#                     2018      Timo Kaufmann <timokau@zoho.com>
+#                     2018      Julian Rüth <julian.rueth@fsfe.org>
+#
+# 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 .backend_cdd import Polyhedron_cdd
+from .base_RDF import Polyhedron_RDF
+
+
+class Polyhedron_RDF_cdd(Polyhedron_cdd, Polyhedron_RDF):
+    """
+    Polyhedra over RDF with cdd.
+
+    INPUT:
+
+    - ``ambient_dim`` -- integer; the dimension of the ambient space
+
+    - ``Vrep`` -- list ``[vertices, rays, lines]`` or ``None``
+
+    - ``Hrep`` -- list ``[ieqs, eqns]`` or ``None``
+
+    EXAMPLES::
+
+        sage: from sage.geometry.polyhedron.parent import Polyhedra
+        sage: parent = Polyhedra(RDF, 2, backend='cdd')
+        sage: from sage.geometry.polyhedron.backend_cdd_rdf import Polyhedron_RDF_cdd
+        sage: Polyhedron_RDF_cdd(parent, [ [(1,0),(0,1),(0,0)], [], []], None, verbose=False)
+        A 2-dimensional polyhedron in RDF^2 defined as the convex hull of 3 vertices
+
+    TESTS:
+
+    Checks that :issue:`24877` is fixed::
+
+        sage: n1 = 1045602428815736513789288687833080060779
+        sage: n2 = 76591188009721216624438400001815308369088648782156930777145
+        sage: n3 = 141046287872967162025203834781636948939209065735662536571684677443277621519222367249160281646288602157866548267640061850035
+        sage: n4 = 169296796161110084211548448622149955145002732358082778064645608216077666698460018565094060494217
+        sage: verts = [[159852/261157, 227425/261157],
+        ....:  [9/10, 7/10],
+        ....:  [132/179, 143/179],
+        ....:  [8/11, -59/33],
+        ....:  [174/167, 95/167],
+        ....:  [3/2, -1/2],
+        ....:  [-1162016360399650274197433414376009691155/n1,
+        ....:    1626522696050475596930360993440360903664/n1],
+        ....:  [-112565666321600055047037445519656973805313121630809713051718/n2,
+        ....:    -15318574020578896781701071673537253327221557273483622682053/n2],
+        ....:  [-222823992658914823798345935660863293259608796350232624336738123149601409997996952470726909468671437285720616325991022633438/n3,
+        ....:   (-20857694835570598502487921801401627779907095024585170129381924208334510445828894861553290291713792691651471189597832832973*5)/n3],
+        ....:  [-100432602675156818915933977983765863676402454634873648118147187022041830166292457614016362515164/n4,
+        ....:   -429364759737031049317769174492863890735634068814210512342503744054527903830844433491149538512537/n4]]
+        sage: P = Polyhedron(verts, base_ring=RDF)
+        sage: len(P.faces(1))
+        10
+        sage: P.n_vertices()
+        10
+        sage: P.n_facets()
+        10
+
+    Check that :issue:`19803` is fixed::
+
+        sage: from sage.geometry.polyhedron.parent import Polyhedra
+        sage: P_cdd = Polyhedra(RDF, 3, 'cdd')
+        sage: P_cdd([[],[],[]], None)
+        The empty polyhedron in RDF^3
+        sage: Polyhedron(vertices=[], backend='cdd', base_ring=RDF)
+        The empty polyhedron in RDF^0
+    """
+    _cdd_type = 'real'
+
+    _cdd_executable = 'cddexec'
+
+    def __init__(self, parent, Vrep, Hrep, **kwds):
+        """
+        The Python constructor.
+
+        See :class:`Polyhedron_base` for a description of the input
+        data.
+
+        TESTS::
+
+            sage: p = Polyhedron(backend='cdd', base_ring=RDF)
+            sage: type(p)
+            <class 'sage.geometry.polyhedron.parent.Polyhedra_RDF_cdd_with_category.element_class'>
+            sage: TestSuite(p).run()
+        """
+        Polyhedron_cdd.__init__(self, parent, Vrep, Hrep, **kwds)
+
+    def _init_from_Vrepresentation_and_Hrepresentation(self, Vrep, Hrep, verbose=False):
+        """
+        Construct polyhedron from Vrepresentation and Hrepresentation data.
+
+        See :class:`Polyhedron_base` for a description of ``Vrep`` and ``Hrep``.
+
+        .. NOTE::
+
+            The representation is assumed to be correct.
+
+            As long as cdd can obtain a consistent object with Vrepresentation
+            or Hrepresentation no warning is raised. Consistency is checked by
+            comparing the output length of Vrepresentation and Hrepresentation
+            with the input.
+
+            In comparison, the "normal" initialization from Vrepresentation over RDF
+            expects the output length to be consistent with the computed length
+            when re-feeding cdd the outputted Hrepresentation.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.parent import Polyhedra_RDF_cdd
+            sage: from sage.geometry.polyhedron.backend_cdd_rdf import Polyhedron_RDF_cdd
+            sage: parent = Polyhedra_RDF_cdd(RDF, 1, 'cdd')
+            sage: Vrep = [[[0.0], [1.0]], [], []]
+            sage: Hrep = [[[0.0, 1.0], [1.0, -1.0]], []]
+            sage: p = Polyhedron_RDF_cdd(parent, Vrep, Hrep,                    # indirect doctest
+            ....:                        Vrep_minimal=True, Hrep_minimal=True)
+            sage: p
+            A 1-dimensional polyhedron in RDF^1 defined as the convex hull of 2 vertices
+
+        TESTS:
+
+        Test that :issue:`29568` is fixed::
+
+            sage: # needs sage.groups
+            sage: P = polytopes.buckyball(exact=False)
+            sage: Q = P + P.center()
+            sage: P.is_combinatorially_isomorphic(Q)
+            True
+            sage: R = 2*P
+            sage: P.is_combinatorially_isomorphic(R)
+            True
+
+        The polyhedron with zero inequalities works correctly; see :issue:`29899`::
+
+            sage: Vrep = [[], [], [[1.0]]]
+            sage: Hrep = [[], []]
+            sage: p = Polyhedron_RDF_cdd(parent, Vrep, Hrep,                    # indirect doctest
+            ....:                        Vrep_minimal=True, Hrep_minimal=True)
+            sage: p
+            A 1-dimensional polyhedron in RDF^1 defined as the convex hull of 1 vertex and 1 line
+
+        Test that :issue:`30330` is fixed::
+
+            sage: P1 = polytopes.regular_polygon(5, exact=False)
+            sage: P2 = Polyhedron()
+            sage: P1*P2
+            The empty polyhedron in RDF^2
+        """
+        def parse_Vrep(intro, data):
+            count = int(data[0][0])
+            if count != len(vertices) + len(rays) + len(lines):
+                # Upstream claims that nothing can be done about these
+                # cases/that they are features not bugs. Imho, cddlib is
+                # not really suitable for automatic parsing of its output,
+                # the implementation backed by doubles has not really been
+                # optimized for numerical stability, and makes some
+                # somewhat random numerical choices. (But I am not an
+                # expert in that field by any means.) See also
+                # https://github.com/cddlib/cddlib/pull/7.
+                from warnings import warn
+                warn("This polyhedron data is numerically complicated; cdd could not convert between the inexact V and H representation without loss of data. The resulting object might show inconsistencies.")
+
+        def parse_Hrep(intro, data):
+            count = int(data[0][0])
+            infinite_count = len([d for d in data[1:] if d[0] == '1' and all(c == '0' for c in d[1:])])
+            if count - infinite_count != len(ieqs) + len(eqns):
+                # Upstream claims that nothing can be done about these
+                # cases/that they are features not bugs. Imho, cddlib is
+                # not really suitable for automatic parsing of its output,
+                # the implementation backed by doubles has not really been
+                # optimized for numerical stability, and makes some
+                # somewhat random numerical choices. (But I am not an
+                # expert in that field by any means.)
+                from warnings import warn
+                warn("This polyhedron data is numerically complicated; cdd could not convert between the inexact V and H representation without loss of data. The resulting object might show inconsistencies.")
+
+        def try_init(rep):
+            if rep == "Vrep":
+                from .cdd_file_format import cdd_Vrepresentation
+                s = cdd_Vrepresentation(self._cdd_type, vertices, rays, lines)
+            else:
+                # We have to add a trivial inequality, in case the polyhedron is the universe.
+                new_ieqs = ieqs + ((1,) + tuple(0 for _ in range(self.ambient_dim())),)
+
+                from .cdd_file_format import cdd_Hrepresentation
+                s = cdd_Hrepresentation(self._cdd_type, new_ieqs, eqns)
+
+            s = self._run_cdd(s, '--redcheck', verbose=verbose)
+            s = self._run_cdd(s, '--repall', verbose=verbose)
+            Polyhedron_cdd._parse_block(s.splitlines(), 'V-representation', parse_Vrep)
+            Polyhedron_cdd._parse_block(s.splitlines(), 'H-representation', parse_Hrep)
+            self._init_from_cdd_output(s)
+
+        from warnings import catch_warnings, simplefilter
+
+        vertices, rays, lines = (tuple(x) for x in Vrep)
+        ieqs, eqns = (tuple(x) for x in Hrep)
+
+        if not (vertices or rays or lines):
+            # cdd refuses to handle empty polyhedra.
+            self._init_empty_polyhedron()
+            return
+
+        # We prefer the shorter representation.
+        # Note that for the empty polyhedron we prefer Hrepresentation.
+        prim = "Hrep" if len(ieqs) <= len(vertices) + len(rays) else "Vrep"
+        sec = "Vrep" if len(ieqs) <= len(vertices) + len(rays) else "Hrep"
+
+        with catch_warnings():
+            # Raise an error and try the other representation in case of
+            # numerical inconsistency.
+            simplefilter("error")
+            try:
+                try_init(prim)
+            except UserWarning:
+                simplefilter("once")  # Only print the first warning.
+                try_init(sec)

sage/geometry/polyhedron/backend_field.py

@@ -0,0 +1,347 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+The Python backend
+
+While slower than specialized C/C++ implementations, the
+implementation is general and works with any exact field in Sage that
+allows you to define polyhedra.
+
+EXAMPLES::
+
+    sage: # needs sage.rings.number_field
+    sage: p0 = (0, 0)
+    sage: p1 = (1, 0)
+    sage: p2 = (1/2, AA(3).sqrt()/2)
+    sage: equilateral_triangle = Polyhedron([p0, p1, p2])
+    sage: equilateral_triangle.vertices()
+    (A vertex at (0, 0),
+     A vertex at (1, 0),
+     A vertex at (0.500000000000000?, 0.866025403784439?))
+    sage: equilateral_triangle.inequalities()
+    (An inequality (-1, -0.5773502691896258?) x + 1 >= 0,
+     An inequality (1, -0.5773502691896258?) x + 0 >= 0,
+     An inequality (0, 1.154700538379252?) x + 0 >= 0)
+"""
+#*****************************************************************************
+#       Copyright (C) 2014 Volker Braun <vbraun.name@gmail.com>
+#
+# 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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+
+from .base import Polyhedron_base
+
+
+class Polyhedron_field(Polyhedron_base):
+    """
+    Polyhedra over all fields supported by Sage.
+
+    INPUT:
+
+    - ``Vrep`` -- list ``[vertices, rays, lines]`` or ``None``
+
+    - ``Hrep`` -- list ``[ieqs, eqns]`` or ``None``
+
+    EXAMPLES::
+
+        sage: p = Polyhedron(vertices=[(0,0),(AA(2).sqrt(),0),(0,AA(3).sqrt())],        # needs sage.rings.number_field
+        ....:                rays=[(1,1)], lines=[], backend='field', base_ring=AA)
+        sage: TestSuite(p).run()                                                        # needs sage.rings.number_field
+
+    TESTS::
+
+        sage: K.<sqrt3> = QuadraticField(3)                                             # needs sage.rings.number_field
+        sage: p = Polyhedron([(0,0), (1,0), (1/2, sqrt3/2)])                            # needs sage.rings.number_field
+        sage: TestSuite(p).run()                                                        # needs sage.rings.number_field
+
+    Check that :issue:`19013` is fixed::
+
+        sage: # needs sage.rings.number_field
+        sage: x = polygen(ZZ, 'x')
+        sage: K.<phi> = NumberField(x^2 - x - 1, embedding=1.618)
+        sage: P1 = Polyhedron([[0,1], [1,1], [1,-phi+1]])
+        sage: P2 = Polyhedron(ieqs=[[-1,-phi,0]])
+        sage: P1.intersection(P2)
+        The empty polyhedron
+         in (Number Field in phi with defining polynomial x^2 - x - 1 with phi = 1.618033988749895?)^2
+
+    Check that :issue:`28654` is fixed::
+
+        sage: Polyhedron(lines=[[1]], backend='field')
+        A 1-dimensional polyhedron in QQ^1 defined as the convex hull of 1 vertex and 1 line
+    """
+    def _is_zero(self, x):
+        """
+        Test whether ``x`` is zero.
+
+        INPUT:
+
+        - ``x`` -- a number in the base ring
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([(sqrt(3),sqrt(2))], base_ring=AA)                     # needs sage.rings.number_field sage.symbolic
+            sage: p._is_zero(0)                                                         # needs sage.rings.number_field sage.symbolic
+            True
+            sage: p._is_zero(1/100000)                                                  # needs sage.rings.number_field sage.symbolic
+            False
+        """
+        return x == 0
+
+    def _is_nonneg(self, x):
+        """
+        Test whether ``x`` is nonnegative.
+
+        INPUT:
+
+        - ``x`` -- a number in the base ring
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([(sqrt(3),sqrt(2))], base_ring=AA)                     # needs sage.rings.number_field sage.symbolic
+            sage: p._is_nonneg(1)                                                       # needs sage.rings.number_field sage.symbolic
+            True
+            sage: p._is_nonneg(-1/100000)                                               # needs sage.rings.number_field sage.symbolic
+            False
+        """
+        return x >= 0
+
+    def _is_positive(self, x):
+        """
+        Test whether ``x`` is positive.
+
+        INPUT:
+
+        - ``x`` -- a number in the base ring
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: p = Polyhedron([(sqrt(3),sqrt(2))], base_ring=AA)                     # needs sage.rings.number_field sage.symbolic
+            sage: p._is_positive(1)                                                     # needs sage.rings.number_field sage.symbolic
+            True
+            sage: p._is_positive(0)                                                     # needs sage.rings.number_field sage.symbolic
+            False
+        """
+        return x > 0
+
+    def _init_from_Vrepresentation_and_Hrepresentation(self, Vrep, Hrep):
+        """
+        Construct polyhedron from V-representation and H-representation data.
+
+        See :class:`Polyhedron_base` for a description of ``Vrep`` and ``Hrep``.
+
+        .. WARNING::
+
+            The representation is assumed to be correct.
+            It is not checked.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.parent import Polyhedra_field
+            sage: from sage.geometry.polyhedron.backend_field import Polyhedron_field
+            sage: parent = Polyhedra_field(AA, 1, 'field')                              # needs sage.rings.number_field
+            sage: Vrep = [[[0], [1]], [], []]
+            sage: Hrep = [[[0, 1], [1, -1]], []]
+            sage: p = Polyhedron_field(parent, Vrep, Hrep,  # indirect doctest          # needs sage.rings.number_field
+            ....:                      Vrep_minimal=True, Hrep_minimal=True)
+            sage: p                                                                     # needs sage.rings.number_field
+            A 1-dimensional polyhedron in AA^1 defined as the convex hull of 2 vertices
+        """
+        self._init_Vrepresentation(*Vrep)
+        self._init_Hrepresentation(*Hrep)
+
+    def _init_from_Vrepresentation(self, vertices, rays, lines,
+                                   minimize=True, verbose=False,
+                                   internal_base_ring=None):
+        """
+        Construct polyhedron from V-representation data.
+
+        INPUT:
+
+        - ``vertices`` -- list of points; each point can be specified
+          as any iterable container of ``internal_base_ring`` elements
+
+        - ``rays`` -- list of rays; each ray can be specified as any
+          iterable container of ``internal_base_ring`` elements
+
+        - ``lines`` -- list of lines; each line can be specified asinternal_base_ring
+          any iterable container of ``internal_base_ring`` elements
+
+        - ``verbose`` -- boolean (default: ``False``); whether to print
+          verbose output for debugging purposes
+
+        - ``internal_base_ring`` -- the base ring of the generators' components;
+          default is ``None``, in which case, it is set to
+          :meth:`~sage.geometry.polyhedron.base.base_ring`
+
+        EXAMPLES::
+
+            sage: p = Polyhedron(ambient_dim=2, backend='field')
+            sage: from sage.geometry.polyhedron.backend_field import Polyhedron_field
+            sage: Polyhedron_field._init_from_Vrepresentation(p, [(0,0)], [], [])
+        """
+        if internal_base_ring is None:
+            internal_base_ring = self.base_ring()
+        from sage.geometry.polyhedron.double_description_inhomogeneous import Hrep2Vrep, Vrep2Hrep
+        H = Vrep2Hrep(internal_base_ring, self.ambient_dim(), vertices, rays, lines)
+        V = Hrep2Vrep(internal_base_ring, self.ambient_dim(),
+                      H.inequalities, H.equations)
+        self._init_Vrepresentation_backend(V)
+        self._init_Hrepresentation_backend(H)
+
+    def _init_from_Hrepresentation(self, ieqs, eqns,
+                                   minimize=True, verbose=False,
+                                   internal_base_ring=None):
+        """
+        Construct polyhedron from H-representation data.
+
+        INPUT:
+
+        - ``ieqs`` -- list of inequalities; each line can be specified
+          as any iterable container of ``internal_base_ring`` elements
+
+        - ``eqns`` -- list of equalities; each line can be specified
+          as any iterable container of ``internal_base_ring`` elements
+
+        - ``verbose`` -- boolean (default: ``False``); whether to print
+          verbose output for debugging purposes
+
+        - ``internal_base_ring`` -- the base ring of the generators' components;
+          default is ``None``, in which case, it is set to
+          :meth:`~sage.geometry.polyhedron.base.base_ring`
+
+        TESTS::
+
+            sage: p = Polyhedron(ambient_dim=2, backend='field')
+            sage: from sage.geometry.polyhedron.backend_field import Polyhedron_field
+            sage: Polyhedron_field._init_from_Hrepresentation(p, [(1, 2, 3)], [])
+        """
+        if internal_base_ring is None:
+            internal_base_ring = self.base_ring()
+        from sage.geometry.polyhedron.double_description_inhomogeneous import Hrep2Vrep, Vrep2Hrep
+        V = Hrep2Vrep(internal_base_ring, self.ambient_dim(), ieqs, eqns)
+        H = Vrep2Hrep(internal_base_ring, self.ambient_dim(),
+                      V.vertices, V.rays, V.lines)
+        self._init_Vrepresentation_backend(V)
+        self._init_Hrepresentation_backend(H)
+
+    def _init_Vrepresentation(self, vertices, rays, lines):
+        """
+        Create the Vrepresentation objects from the given minimal data.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.parent import Polyhedra_field
+            sage: from sage.geometry.polyhedron.backend_field import Polyhedron_field
+            sage: parent = Polyhedra_field(AA, 1, 'field')                              # needs sage.rings.number_field
+            sage: Vrep = [[[0], [1]], [], []]
+            sage: Hrep = [[[0, 1], [1, -1]], []]
+            sage: p = Polyhedron_field(parent, Vrep, Hrep,  # indirect doctest          # needs sage.rings.number_field
+            ....:                      Vrep_minimal=True,
+            ....:                      Hrep_minimal=True)
+            sage: p.vertices_list()                                                     # needs sage.rings.number_field
+            [[0], [1]]
+        """
+        self._Vrepresentation = []
+        parent = self.parent()
+        for v in vertices:
+            parent._make_Vertex(self, v)
+        for r in rays:
+            parent._make_Ray(self, r)
+        for l in lines:
+            parent._make_Line(self, l)
+        self._Vrepresentation = tuple(self._Vrepresentation)
+
+    def _init_Vrepresentation_backend(self, Vrep):
+        """
+        Create the V-representation objects from the double description.
+
+        EXAMPLES::
+
+            sage: p = Polyhedron(vertices=[(0, 1/sqrt(2)),  # indirect doctest          # needs sage.rings.number_field sage.symbolic
+            ....:                          (sqrt(2), 0),
+            ....:                          (4, sqrt(5)/6)],
+            ....:                base_ring=AA, backend='field')
+            sage: p.Hrepresentation()                                                   # needs sage.rings.number_field sage.symbolic
+            (An inequality (-0.1582178750233332?, 1.097777812326429?) x + 0.2237538646678492? >= 0,
+             An inequality (-0.1419794359520263?, -1.698172434277148?) x + 1.200789243901438? >= 0,
+             An inequality (0.3001973109753594?, 0.600394621950719?) x - 0.4245431085692869? >= 0)
+            sage: p.Vrepresentation()                                                   # needs sage.rings.number_field sage.symbolic
+            (A vertex at (0.?e-16, 0.7071067811865475?),
+             A vertex at (1.414213562373095?, 0),
+             A vertex at (4.000000000000000?, 0.372677996249965?))
+        """
+        self._init_Vrepresentation(Vrep.vertices, Vrep.rays, Vrep.lines)
+
+    def _init_Hrepresentation(self, inequalities, equations):
+        """
+        Create the Vrepresentation objects from the given minimal data.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.polyhedron.parent import Polyhedra_field
+            sage: from sage.geometry.polyhedron.backend_field import Polyhedron_field
+            sage: parent = Polyhedra_field(AA, 1, 'field')                              # needs sage.rings.number_field
+            sage: Vrep = [[[0], [1]], [], []]
+            sage: Hrep = [[[0, 1], [1, -1]], []]
+            sage: p = Polyhedron_field(parent, Vrep, Hrep,  # indirect doctest          # needs sage.rings.number_field
+            ....:                      Vrep_minimal=True, Hrep_minimal=True)
+            sage: p.inequalities_list()                                                 # needs sage.rings.number_field
+            [[0, 1], [1, -1]]
+        """
+        self._Hrepresentation = []
+        parent = self.parent()
+        for ieq in inequalities:
+            parent._make_Inequality(self, ieq)
+        for eqn in equations:
+            parent._make_Equation(self, eqn)
+        self._Hrepresentation = tuple(self._Hrepresentation)
+
+    def _init_Hrepresentation_backend(self, Hrep):
+        """
+        Create the H-representation objects from the double description.
+
+        EXAMPLES::
+
+            sage: p = Polyhedron(vertices=[(0, 1/sqrt(2)),  # indirect doctest          # needs sage.rings.number_field sage.symbolic
+            ....:                          (sqrt(2), 0),
+            ....:                          (4, sqrt(5)/6)],
+            ....:                base_ring=AA, backend='field')
+            sage: p.Hrepresentation()                                                   # needs sage.rings.number_field sage.symbolic
+            (An inequality (-0.1582178750233332?, 1.097777812326429?) x + 0.2237538646678492? >= 0,
+             An inequality (-0.1419794359520263?, -1.698172434277148?) x + 1.200789243901438? >= 0,
+             An inequality (0.3001973109753594?, 0.600394621950719?) x - 0.4245431085692869? >= 0)
+            sage: p.Vrepresentation()                                                   # needs sage.rings.number_field sage.symbolic
+            (A vertex at (0.?e-16, 0.7071067811865475?),
+             A vertex at (1.414213562373095?, 0),
+             A vertex at (4.000000000000000?, 0.372677996249965?))
+        """
+        self._init_Hrepresentation(Hrep.inequalities, Hrep.equations)
+
+    def _init_empty_polyhedron(self):
+        """
+        Initialize an empty polyhedron.
+
+        TESTS::
+
+            sage: empty = Polyhedron(backend='field', base_ring=AA); empty              # needs sage.rings.number_field
+            The empty polyhedron in AA^0
+            sage: empty.Vrepresentation()                                               # needs sage.rings.number_field
+            ()
+            sage: empty.Hrepresentation()                                               # needs sage.rings.number_field
+            (An equation -1 == 0,)
+            sage: Polyhedron(vertices=[], backend='field')
+            The empty polyhedron in QQ^0
+            sage: Polyhedron(backend='field')._init_empty_polyhedron()
+        """
+        super()._init_empty_polyhedron()