passagemath-modules 10.6.31rc3__cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

sage/misc/sphinxify.py

@@ -0,0 +1,167 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: optional - sphinx
+r"""
+Process docstrings with Sphinx
+
+Processes docstrings with Sphinx. Can also be used as a commandline script:
+
+``python sphinxify.py <text>``
+
+AUTHORS:
+
+- Tim Joseph Dumol (2009-09-29): initial version
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2009 Tim Dumol <tim@timdumol.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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import builtins
+import os
+import re
+import shutil
+import sys
+from tempfile import mkdtemp
+from sphinx.application import Sphinx
+
+
+def sphinxify(docstring, format='html'):
+    r"""
+    Run Sphinx on a ``docstring``, and output the processed documentation.
+
+    INPUT:
+
+    - ``docstring`` -- string; a ReST-formatted docstring
+
+    - ``format`` -- string (default: ``'html'``); either ``'html'`` or
+      ``'text'``
+
+    OUTPUT:
+
+    - ``string`` -- Sphinx-processed documentation, in either HTML or
+      plain text format, depending on the value of ``format``
+
+    EXAMPLES::
+
+        sage: from sage.misc.sphinxify import sphinxify
+        sage: sphinxify('A test')
+        '<div class="docstring">\n    \n  <p>A test</p>\n\n\n</div>'
+        sage: sphinxify('**Testing**\n`monospace`')
+        '<div class="docstring"...<strong>Testing</strong>\n<span class="math...</p>\n\n\n</div>'
+        sage: sphinxify('`x=y`')
+        '<div class="docstring">\n    \n  <p><span class="math notranslate nohighlight">x=y</span></p>\n\n\n</div>'
+        sage: sphinxify('`x=y`', format='text')
+        'x=y\n'
+        sage: sphinxify(':math:`x=y`', format='text')
+        'x=y\n'
+
+    TESTS::
+
+        sage: n = len(sys.path)
+        sage: _ = sphinxify('A test')
+        sage: assert n == len(sys.path)
+    """
+    srcdir = mkdtemp()
+    outdir = mkdtemp()
+    src_base_name = os.path.join(srcdir, 'docstring')
+    out_base_name = os.path.join(outdir, 'docstring')
+    rst_name = src_base_name + '.rst'
+
+    if format == 'html':
+        suffix = '.html'
+    else:
+        suffix = '.txt'
+    output_name = out_base_name + suffix
+
+    with open(rst_name, 'w') as filed:
+        filed.write(docstring)
+
+    confdir = os.path.join(srcdir, 'en', 'introspect')
+    os.makedirs(confdir)
+    with open(os.path.join(confdir, 'conf.py'), 'w') as filed:
+        filed.write(r"""
+from sage.misc.sagedoc_conf import *
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.mathjax', 'sphinx.ext.todo', 'sphinx.ext.extlinks']
+
+templates_path = ['templates']
+html_static_path = ['static']
+
+html_use_modindex = False
+html_use_index = False
+html_split_index = False
+html_copy_source = False
+
+todo_include_todos = True""")
+    templatesdir = os.path.join(confdir, 'templates')
+    os.makedirs(templatesdir)
+    with open(os.path.join(templatesdir, 'layout.html'), 'w') as filed:
+        filed.write(r"""<div class="docstring">
+    {% block body %} {% endblock %}
+</div>""")
+    staticdir = os.path.join(confdir, 'static')
+    os.makedirs(staticdir)
+    with open(os.path.join(staticdir, 'empty'), 'w') as filed:
+        pass
+    with open(os.path.join(srcdir, 'docutils.conf'), 'w') as filed:
+        filed.write(r"""
+[parsers]
+smart_quotes = no""")
+    doctreedir = os.path.join(srcdir, 'doctrees')
+    confoverrides = {'html_context': {}, 'master_doc': 'docstring'}
+
+    old_sys_path = list(sys.path)  # Sphinx modifies sys.path
+    # Sphinx constructor: Sphinx(srcdir, confdir, outdir, doctreedir,
+    # buildername, confoverrides, status, warning, freshenv).
+    sphinx_app = Sphinx(srcdir, confdir, outdir, doctreedir, format,
+                        confoverrides, None, None, True)
+    sphinx_app.build(None, [rst_name])
+    sys.path = old_sys_path
+
+    # We need to remove "_" from __builtin__ that the gettext module installs
+    builtins.__dict__.pop('_', None)
+
+    if os.path.exists(output_name):
+        with open(output_name) as f:
+            output = f.read()
+        output = output.replace('<pre>', '<pre class="literal-block">')
+
+        # Translate URLs for media from something like
+        #    "../../media/...path.../blah.png"
+        # or
+        #    "/media/...path.../blah.png"
+        # to
+        #    "/doc/static/reference/media/...path.../blah.png"
+        output = re.sub(r"""src=['"](/?\.\.)*/?media/([^"']*)['"]""",
+                        'src="/doc/static/reference/media/\\2"',
+                        output)
+        # Remove spurious \(, \), \[, \].
+        output = output.replace(r'\(', '').replace(r'\)', '').replace(r'\[', '').replace(r'\]', '')
+    else:
+        from warnings import warn
+        warn("Sphinx did not produce any output", Warning)
+        if format == 'html':
+            output = '<pre class="introspection">%s</pre>' % docstring
+        else:
+            output = docstring
+
+    shutil.rmtree(srcdir, ignore_errors=True)
+    shutil.rmtree(outdir, ignore_errors=True)
+
+    return output
+
+
+if __name__ == '__main__':
+    if len(sys.argv) == 2:
+        print(sphinxify(sys.argv[1]))
+    else:
+        print("""Usage:
+%s 'docstring'
+
+docstring -- docstring to be processed
+""")

sage/misc/test_class_pickling.py

@@ -0,0 +1,85 @@
+# sage_setup: distribution = sagemath-modules
+
+import copyreg
+
+
+class bar:
+    pass
+
+
+def metaclass(name, bases):
+    """
+    Create a new class in this metaclass.
+
+    INPUT:
+
+    - ``name`` -- string
+    - ``bases`` -- tuple of classes
+
+    EXAMPLES::
+
+        sage: from sage.misc.test_class_pickling import metaclass, bar
+        sage: c = metaclass("foo2", (bar, object))
+        constructing class
+        sage: c
+        <class 'sage.misc.test_class_pickling.foo2'>
+        sage: type(c)
+        <class 'sage.misc.test_class_pickling.Metaclass'>
+        sage: c.__bases__
+        (<...sage.misc.test_class_pickling.bar...>, <... 'object'>)
+    """
+    print("constructing class")
+    result = Metaclass(name, bases, {})
+    result.reduce_args = (name, bases)
+    return result
+
+
+class Metaclass(type):
+    """
+    This metaclass illustrates the customization of how a class is pickled.
+    It requires a slightly patched version of cPickle.
+
+    See:
+
+    - https://docs.python.org/3/library/copyreg.html#module-copyreg
+    - http://groups.google.com/group/comp.lang.python/browse_thread/thread/66c282afc04aa39c/
+    - http://groups.google.com/group/sage-devel/browse_thread/thread/583048dc7d373d6a/
+
+    EXAMPLES::
+
+        sage: from sage.misc.test_class_pickling import metaclass, bar
+        sage: c = metaclass("foo", (bar, object))
+        constructing class
+        sage: import pickle
+        sage: s = pickle.dumps(c)
+        reducing a class
+        sage: c2 = pickle.loads(s)
+        constructing class
+        sage: c == c2
+        calling __eq__ defined in Metaclass
+        True
+    """
+    def __eq__(self, other):
+        print("calling __eq__ defined in Metaclass")
+        return (type(self) is type(other)) and (self.reduce_args == other.reduce_args)
+
+    def __reduce__(self):
+        """
+        Implement the pickle protocol for classes in this metaclass
+        (not for the instances of this class!!!)
+
+        EXAMPLES::
+
+            sage: from sage.misc.test_class_pickling import metaclass, bar
+            sage: c = metaclass("foo3", (bar, object))
+            constructing class
+            sage: c.__class__.__reduce__(c)
+            reducing a class
+            (<function metaclass at ...>,
+             ('foo3', (<...sage.misc.test_class_pickling.bar...>, <...'object'>)))
+        """
+        print("reducing a class")
+        return (metaclass, self.reduce_args)
+
+
+copyreg.pickle(Metaclass, Metaclass.__reduce__)

sage/modules/all.py

@@ -0,0 +1,42 @@
+# sage_setup: distribution = sagemath-modules
+# *****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code 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.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.modules.free_module import FreeModule, VectorSpace, span
+
+from sage.modules.free_quadratic_module import (
+    FreeQuadraticModule,
+    QuadraticSpace,
+    InnerProductSpace,
+)
+
+from sage.modules.free_module_element import (
+    vector,
+    free_module_element,
+    zero_vector,
+    random_vector,
+)
+
+from sage.modules.vector_space_morphism import linear_transformation
+
+from sage.modules.with_basis.all import *
+
+from sage.misc.lazy_import import lazy_import
+
+lazy_import("sage.modules.filtered_vector_space", "FilteredVectorSpace")
+lazy_import("sage.modules.multi_filtered_vector_space", "MultiFilteredVectorSpace")
+lazy_import("sage.modules.free_quadratic_module_integer_symmetric", "IntegralLattice")
+lazy_import("sage.modules.torsion_quadratic_module", "TorsionQuadraticForm")
+del lazy_import

sage/modules/complex_double_vector.py

@@ -0,0 +1,25 @@
+# sage_setup: distribution = sagemath-modules
+r"""
+Pickling for the old CDF vector class
+
+AUTHORS:
+
+- Jason Grout
+
+TESTS::
+
+    sage: v = vector(CDF,[(1,-1), (2,pi), (3,5)]); v                                    # needs sage.symbolic
+    (1.0 - 1.0*I, 2.0 + 3.141592653589793*I, 3.0 + 5.0*I)
+    sage: loads(dumps(v)) == v                                                          # needs sage.symbolic
+    True
+"""
+
+###############################################################################
+#       Copyright (C) 2008 Jason Grout <jason-sage@creativetrax.com>
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+###############################################################################
+
+from sage.modules.vector_complex_double_dense import Vector_complex_double_dense
+
+ComplexDoubleVectorSpaceElement = Vector_complex_double_dense

sage/modules/diamond_cutting.py

@@ -0,0 +1,380 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.geometry.polyhedron
+"""
+Diamond cutting implementation
+
+AUTHORS:
+
+- Jan Poeschko (2012-07-02): initial version
+"""
+# ****************************************************************************
+#       Copyright (C) 2012 Jan Poeschko <jan@poeschko.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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.geometry.polyhedron.constructor import Polyhedron
+from sage.matrix.constructor import matrix
+from sage.modules.free_module_element import vector
+
+from math import sqrt, floor, ceil
+
+
+def plane_inequality(v) -> list:
+    """
+    Return the inequality for points on the same side as the origin
+    with respect to the plane through ``v`` normal to ``v``.
+
+    EXAMPLES::
+
+        sage: from sage.modules.diamond_cutting import plane_inequality
+        sage: ieq = plane_inequality([1, -1]); ieq
+        [2, -1, 1]
+        sage: ieq[0] + vector(ieq[1:]) * vector([1, -1])
+        0
+    """
+    v = vector(v)
+    c = -v * v
+    if c < 0:
+        c, v = -c, -v
+    return [c] + list(v)
+
+
+def jacobi(M):
+    r"""
+    Compute the upper-triangular part of the Cholesky/Jacobi
+    decomposition of the symmetric matrix ``M``.
+
+    Let `M` be a symmetric `n \times n`-matrix over a field `F`.
+    Let `m_{i,j}` denote the `(i,j)`-th entry of `M` for any
+    `1 \leq i \leq n` and `1 \leq j \leq n`. Then, the
+    upper-triangular part computed by this method is the
+    upper-triangular `n \times n`-matrix `Q` whose
+    `(i,j)`-th entry `q_{i,j}` satisfies
+
+    .. MATH::
+
+        q_{i,j} =
+        \begin{cases}
+            \frac{1}{q_{i,i}} \left( m_{i,j} - \sum_{r<i} q_{r,r} q_{r,i} q_{r,j} \right) & i < j, \\
+            m_{i,j} - \sum_{r<i} q_{r,r} q_{r,i}^2 & i = j, \\
+            0 & i > j,
+        \end{cases}
+
+    for all `1 \leq i \leq n` and `1 \leq j \leq n`. (These
+    equalities determine the entries of `Q` uniquely by
+    recursion.) This matrix `Q` is defined for every invertible
+    `n \times n`-matrix `M`. Its definition is taken from (2.3)
+    of [FP1985]_.
+
+    .. NOTE::
+
+        This should be a method of matrices.
+
+    EXAMPLES::
+
+        sage: from sage.modules.diamond_cutting import jacobi
+        sage: jacobi(identity_matrix(3) * 4)
+        [4 0 0]
+        [0 4 0]
+        [0 0 4]
+
+        sage: def testall(M):
+        ....:      Q = jacobi(M)
+        ....:      for j in range(3):
+        ....:          for i in range(j):
+        ....:              if Q[i,j] * Q[i,i] != M[i,j] - sum(Q[r,i] * Q[r,j] * Q[r,r] for r in range(i)):
+        ....:                  return False
+        ....:      for i in range(3):
+        ....:          if Q[i,i] != M[i,i] - sum(Q[r,i] ** 2 * Q[r,r] for r in range(i)):
+        ....:              return False
+        ....:          for j in range(i):
+        ....:              if Q[i,j] != 0:
+        ....:                  return False
+        ....:      return True
+
+        sage: M = Matrix(QQ, [[8,1,5], [1,6,0], [5,0,3]])
+        sage: Q = jacobi(M); Q
+        [    8   1/8   5/8]
+        [    0  47/8 -5/47]
+        [    0     0 -9/47]
+        sage: testall(M)
+        True
+
+        sage: M = Matrix(QQ, [[3,6,-1,7],[6,9,8,5],[-1,8,2,4],[7,5,4,0]])
+        sage: testall(M)
+        True
+    """
+    if not M.is_square():
+        raise ValueError("the matrix must be square")
+    dim = M.nrows()
+    q = [list(row) for row in M]
+    for i in range(dim - 1):
+        for j in range(i + 1, dim):
+            q[j][i] = q[i][j]
+            q[i][j] = q[i][j] / q[i][i]
+        for k in range(i + 1, dim):
+            for l in range(k, dim):
+                q[k][l] -= q[k][i] * q[i][l]
+    for i in range(1, dim):
+        for j in range(i):
+            q[i][j] = 0
+    return matrix(q)
+
+
+def diamond_cut(V, GM, C, verbose=False) -> Polyhedron:
+    r"""
+    Perform diamond cutting on polyhedron ``V`` with basis matrix ``GM``
+    and squared radius ``C``.
+
+    INPUT:
+
+    - ``V`` -- polyhedron to cut from
+
+    - ``GM`` -- half of the basis matrix of the lattice
+
+    - ``C`` -- square of the radius to use in cutting algorithm
+
+    - ``verbose`` -- boolean (default: ``False``); whether to print
+      debug information
+
+    OUTPUT: a :class:`Polyhedron` instance
+
+    ALGORITHM:
+
+    Use the algorithm in (2.8) of [FP1985]_ to iterate through the nonzero
+    vectors ``hv`` of length at most `\sqrt{C}` in the lattice spanned by
+    ``GM``. (Actually, the algorithm only constructs one vector from each pair
+    ``{hv, -hv}``.) For each such vector ``hv``, intersect ``V`` with the
+    half-spaces defined by ``plane_inequality(hv)`` and
+    ``plane_inequality(-hv)``.
+
+    EXAMPLES::
+
+        sage: from sage.modules.diamond_cutting import diamond_cut
+        sage: V = Polyhedron([[0], [2]])
+        sage: GM = matrix([2])
+        sage: V = diamond_cut(V, GM, 4)
+        sage: V.vertices()
+        (A vertex at (2), A vertex at (0))
+
+    TESTS:
+
+    Verify that code works when no cuts are performed::
+
+        sage: from sage.modules.free_module_integer import IntegerLattice
+        sage: v = vector(ZZ, [1,1,-1])
+        sage: L = IntegerLattice([v])
+        sage: C = L.voronoi_cell(radius=0.1)
+    """
+    if verbose:
+        print("Cut\n{}\nwith squared radius {}".format(GM, C))
+
+    dim = GM.dimensions()
+    if dim[0] != dim[1]:
+        raise ValueError("the matrix must be square")
+    dim = dim[0]
+    T = [0] * dim
+    U = [0] * dim
+    x = [0] * dim
+    L = [0] * dim
+
+    # calculate the Gram matrix
+    q = matrix([[sum(GM[i][k] * GM[j][k] for k in range(dim))
+                 for j in range(dim)] for i in range(dim)])
+    if verbose:
+        print("q:\n{}".format(q.n()))
+    # apply Cholesky/Jacobi decomposition
+    q = jacobi(q)
+    if verbose:
+        print("q:\n{}".format(q.n()))
+
+    i = dim - 1
+    T[i] = C
+    U[i] = 0
+
+    new_dimension = True
+    cut_count = 0
+    inequalities = []
+    while True:
+        if verbose:
+            print(f"Dimension: {i}")
+        if new_dimension:
+            Z = sqrt(T[i] / q[i][i])
+            if verbose:
+                print("Z: {}".format(Z))
+            L[i] = int(floor(Z - U[i]))
+            if verbose:
+                print("L: {}".format(L))
+            x[i] = int(ceil(-Z - U[i]) - 1)
+            new_dimension = False
+
+        x[i] += 1
+        if verbose:
+            print(f"x: {x}")
+        if x[i] > L[i]:
+            i += 1
+        elif i > 0:
+            T[i - 1] = T[i] - q[i][i] * (x[i] + U[i]) ** 2
+            i -= 1
+            U[i] = 0
+            for j in range(i + 1, dim):
+                U[i] += q[i][j] * x[j]
+            new_dimension = True
+        else:
+            if all(elmt == 0 for elmt in x):
+                break
+            hv = [0] * dim
+            for k in range(dim):
+                for j in range(dim):
+                    hv[k] += x[j] * GM[j][k]
+            hv = vector(hv)
+
+            for hv in [hv, -hv]:
+                cut_count += 1
+                if verbose:
+                    print("\n%d) Cut using normal vector %s" % (cut_count, hv))
+                inequalities.append(plane_inequality(hv))
+
+    if verbose:
+        print("Final cut")
+    if inequalities:
+        cut = Polyhedron(ieqs=inequalities)
+        V = V.intersection(cut)
+
+    if verbose:
+        print("End")
+
+    return V
+
+
+def calculate_voronoi_cell(basis, radius=None, verbose=False) -> Polyhedron:
+    """
+    Calculate the Voronoi cell of the lattice defined by basis.
+
+    INPUT:
+
+    - ``basis`` -- embedded basis matrix of the lattice
+
+    - ``radius`` -- square of radius of basis vectors to consider
+
+    - ``verbose`` -- whether to print debug information
+
+    OUTPUT: a :class:`Polyhedron` instance
+
+    EXAMPLES::
+
+        sage: from sage.modules.diamond_cutting import calculate_voronoi_cell
+        sage: V = calculate_voronoi_cell(matrix([[1, 0], [0, 1]]))
+        sage: V.volume()
+        1
+
+    TESTS:
+
+    Verify that :issue:`39507` is fixed::
+
+        sage: from sage.modules.free_module_integer import IntegerLattice
+        sage: v = vector(ZZ, [1,1,1,-1])
+        sage: L = IntegerLattice([v])
+        sage: print(v in L)
+        True
+        sage: print(L.closest_vector(v))
+        (1, 1, 1, -1)
+        sage: C = L.voronoi_cell()
+        sage: C.Hrepresentation()
+        (An inequality (-1, -1, -1, 1) x + 2 >= 0,
+         An inequality (1, 1, 1, -1) x + 2 >= 0)
+        sage: v = vector(ZZ, [1,1,-1])
+        sage: L = IntegerLattice([v])
+        sage: C = L.voronoi_cell()
+        sage: C.Hrepresentation()
+        (An inequality (-2, -2, 2) x + 3 >= 0,
+         An inequality (2, 2, -2) x + 3 >= 0)
+        sage: C.Vrepresentation()
+        (A line in the direction (0, 1, 1),
+         A line in the direction (1, 0, 1),
+         A vertex at (0, 0, -3/2),
+         A vertex at (0, 0, 3/2))
+
+    Verify that :issue:`37086` is fixed::
+
+        sage: from sage.modules.free_module_integer import IntegerLattice
+        sage: l  = [7, 0, -1, -2, -1, -2, 7, -2, 0, 0, -2,
+        ....:       0, 7, -2, 0, -1, -2, -1, 7, 0 , -1, -1, 0, -2, 7]
+        sage: M = matrix(5, 5, l)
+        sage: C = IntegerLattice(M).voronoi_cell()
+        sage: C
+        A 5-dimensional polyhedron in QQ^5 defined as the
+        convex hull of 720 vertices
+    """
+    dim = basis.dimensions()
+    # LLL-reduce for efficiency.
+    basis = basis.LLL()
+    if radius is None:
+        # Convert the basis matrix to use RDF numbers for efficiency when we
+        # calculate the triangular matrix of the QR decomposition.
+        from sage.rings.real_double import RDF
+        transposed_RDF_matrix = (basis.transpose()).change_ring(RDF)
+        R = transposed_RDF_matrix.QR()[1]
+        # The length of the vector formed by the diagonal entries of R is an
+        # upper bound for twice the covering radius, so it is an upper bound
+        # on the length of the lattice vectors that need to be considered for
+        # diamond cutting. However, the value of the `radius` keyword is
+        # actually a squared length, so there is no square root in the
+        # following formula.
+        radius = sum(R[i, i]**2 for i in range(dim[0]))
+        # We then divide by 4 as we will divide the basis by 2 later on.
+        radius = ceil(radius / 4)
+    artificial_length = None
+    if dim[0] < dim[1]:
+        F = basis.base_ring().fraction_field()
+        # Introduce "artificial" basis points (representing infinity).
+        additional_vectors = (F**dim[1]).subspace(basis).complement().basis()
+        additional_vectors = matrix(additional_vectors)
+        # LLL-reduce for efficiency.
+        additional_vectors = additional_vectors.LLL()
+
+        from sage.rings.real_double import RDF
+        # Convert the basis matrix to use RDF numbers for efficiency when we
+        # perform the QR decomposition.
+        transposed_RDF_matrix = additional_vectors.transpose().change_ring(RDF)
+        R = transposed_RDF_matrix.QR()[1]
+        # Since R is triangular, its smallest diagonal entry provides a
+        # lower bound on the length of the shortest nonzero vector in the
+        # lattice spanned by the artificial points. We square it because
+        # value of `radius` is a squared length.
+        shortest_vector_lower_bound = min(R[i, i]**2
+                                          for i in range(dim[1] - dim[0]))
+        # We will multiply our artificial points by the following scalar in
+        # order to make sure the squared length of the shortest
+        # nonzero vector is greater than radius, even after the vectors
+        # are divided by 2.
+        artificial_length = ceil(2.001 * sqrt(radius / shortest_vector_lower_bound))
+        additional_vectors *= artificial_length
+        basis = basis.stack(additional_vectors)
+        basis = matrix([v for v in basis if v])
+        dim = basis.dimensions()
+    if dim[0] != dim[1]:
+        raise ValueError("invalid matrix")
+    basis = basis / 2
+
+    ieqs = []
+    for v in basis:
+        ieqs.append(plane_inequality(v))
+        ieqs.append(plane_inequality(-v))
+    Q = Polyhedron(ieqs=ieqs)
+
+    V = diamond_cut(Q, basis, radius, verbose=verbose)
+
+    if artificial_length is not None:
+        # Remove inequalities introduced by artificial basis points.
+        H = V.Hrepresentation()
+        H = [v for v in H if all(not V._is_zero(v.A() * w / 2 - v.b()) and
+                                 not V._is_zero(v.A() * (-w) / 2 - v.b())
+                                 for w in additional_vectors)]
+        V = Polyhedron(ieqs=H)
+
+    return V

sage/modules/fg_pid/all.py

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