passagemath-frobby 10.5.41__cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

passagemath_frobby-10.5.41.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: passagemath-frobby
+Version: 10.5.41
+Summary: passagemath: Computations on monomial ideals with Frobby
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://doc.sagemath.org
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.14,>=3.9
+Description-Content-Type: text/x-rst
+Requires-Dist: cysignals!=1.12.0,>=1.11.2
+Requires-Dist: passagemath-environment~=10.5.41.0
+Requires-Dist: passagemath-categories~=10.5.41.0
+Provides-Extra: test
+Requires-Dist: passagemath-graphs; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+Requires-Dist: passagemath-singular; extra == "test"
+
+========================================================
+passagemath: Computations on monomial ideals with Frobby
+========================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork was created in October 2024 with the following
+goals:
+
+-  providing modularized installation with pip, thus completing a `major
+   project started in 2020 in the Sage
+   codebase <https://github.com/sagemath/sage/issues/29705>`__,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  providing `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://doc.sagemath.org/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support all major Linux distributions and recent versions of
+macOS. Use on Windows currently requires the use of Windows Subsystem for Linux or
+virtualization.
+
+Complete sets of binary wheels are provided on PyPI for Python versions 3.9.x-3.12.x.
+Python 3.13.x is also supported, but some third-party packages are still missing wheels,
+so compilation from source is triggered for those.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable source distribution ``passagemath-frobby`` provides an interface to Frobby,
+the package for computations on monomial ideals.
+
+
+Examples
+--------
+
+A quick way to try it out interactively::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-frobby[test]" ipython
+
+    In [1]: from sage.all__sagemath_frobby import *

passagemath_frobby-10.5.41.dist-info/RECORD

@@ -0,0 +1,12 @@
+passagemath_frobby.libs/libgmp-b7bc6ccf.so.10.5.0,sha256=wWj9DTad9TDc7qK_-TCSchoWOhjzylvaWDAA_hwYDbA,666681
+passagemath_frobby.libs/libgmpxx-39778ba9.so.4.7.0,sha256=RWCLC1cph7ZjZFzSWFUMjV_YkrIAd7RhjuSHY52Ci9E,400545
+sage/all__sagemath_frobby.py,sha256=ZZLIxeb2nBT4yQeA2DJP-RAv4cu-U6uMgxlMwzt1H2c,172
+sage/interfaces/all__sagemath_frobby.py,sha256=8Gs1smRLFdGXCb2uKk6xy0wkdR8twjy7TlbvxQXV1gc,45
+sage/interfaces/frobby.py,sha256=NAXJL2ybODNM3V1EyjMW_C2KKjt0b9wRVrWLWO5ePnI,16693
+sage/libs/all__sagemath_frobby.py,sha256=8Gs1smRLFdGXCb2uKk6xy0wkdR8twjy7TlbvxQXV1gc,45
+sage/libs/frobby.cpython-311-aarch64-linux-gnu.so,sha256=Q0wRwckFV-qx-dagfwlkoyGEk2V-qVRMdya1ImXjut0,255632
+sage_wheels/bin/frobby,sha256=otfT5wu4b_S95FbhxyU6hWLWQziX2bXlK_NoWxI8chQ,32420016
+passagemath_frobby-10.5.41.dist-info/METADATA,sha256=zD4oLqvKisuophGuT9ngyfK_g7wPGwpiw4fCyHwort4,4360
+passagemath_frobby-10.5.41.dist-info/WHEEL,sha256=kd1DLlG2bxeAxn5uI-koj2s6omEUi3sgz5Bccpa-idw,154
+passagemath_frobby-10.5.41.dist-info/top_level.txt,sha256=hibFyzQHiLOMK68qL1OWsNKaXOmSXqZjeLTBem6Yy7I,5
+passagemath_frobby-10.5.41.dist-info/RECORD,,

passagemath_frobby-10.5.41.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_24_aarch64
+Tag: cp311-cp311-manylinux_2_28_aarch64
+

passagemath_frobby-10.5.41.dist-info/top_level.txt

@@ -0,0 +1 @@
+sage

sage/all__sagemath_frobby.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-frobby
+
+from sage.all__sagemath_categories import *
+from sage.all__sagemath_graphs import *
+from sage.all__sagemath_singular import *

sage/interfaces/all__sagemath_frobby.py

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

sage/interfaces/frobby.py

@@ -0,0 +1,463 @@
+# sage_setup: distribution = sagemath-frobby
+r"""
+Interface to Frobby for fast computations on monomial ideals.
+
+The software package Frobby provides a number of computations on
+monomial ideals. The current main feature is the socle of a monomial
+ideal, which is largely equivalent to computing the maximal standard
+monomials, the Alexander dual or the irreducible decomposition.
+
+Operations on monomial ideals are much faster than algorithms designed
+for ideals in general, which is what makes a specialized library for
+these operations on monomial ideals useful.
+
+AUTHORS:
+
+- Bjarke Hammersholt Roune (2008-04-25): Wrote the Frobby C++
+  program and the initial version of the Python interface.
+
+.. NOTE::
+
+    The official source for Frobby is <https://www.broune.com/frobby>,
+    which also has documentation and papers describing the algorithms used.
+"""
+
+from subprocess import Popen, PIPE
+from sage.misc.misc_c import prod
+
+from sage.cpython.string import bytes_to_str, str_to_bytes
+from sage.features.frobby import Frobby as frobby_executable
+
+
+class Frobby:
+    def __call__(self, action, input=None, options=[], verbose=False):
+        r"""
+        This function calls Frobby as a command line program using streams
+        for input and output. Strings passed as part of the command get
+        broken up at whitespace. This is not done to the data passed
+        via the streams.
+
+        INPUT:
+
+        - ``action`` -- string telling Frobby what to do
+        - ``input`` -- ``None`` or string that is passed to Frobby as standard in
+        - ``options`` -- list of options without the dash in front
+        - ``verbose`` -- boolean (default: ``False``); print detailed information
+
+        OUTPUT: string; what Frobby wrote to the standard output stream
+
+        EXAMPLES:
+
+        We compute the lcm of an ideal provided in Monos format. ::
+
+            sage: frobby("analyze", input="vars x,y,z;[x^2,x*y];", # optional - frobby
+            ....:     options=["lcm", "iformat monos", "oformat 4ti2"])
+            ' 2 1 0\n\n2 generators\n3 variables\n'
+
+
+        We get an exception if frobby reports an error. ::
+
+            sage: frobby("do_dishes") # optional - frobby
+            Traceback (most recent call last):
+            ...
+            RuntimeError: Frobby reported an error:
+            ERROR: No action has the prefix "do_dishes".
+
+        AUTHOR:
+
+        - Bjarke Hammersholt Roune (2008-04-27)
+        """
+        command = [frobby_executable().absolute_filename()] + action.split()
+        for option in options:
+            command += ('-' + option.strip()).split()
+
+        if verbose:
+            print("Frobby action: ", action)
+            print("Frobby options: ", repr(options))
+            print("Frobby command: ", repr(command))
+            print("Frobby input:\n", input)
+
+        process = Popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        if input:
+            frinput = str_to_bytes(input)
+        else:
+            frinput = None
+        output, err = process.communicate(input=frinput)
+        output = bytes_to_str(output)
+        err = bytes_to_str(err)
+
+        if verbose:
+            print("Frobby output:\n", output)
+            print("Frobby error:\n", err)
+        if process.poll() != 0:
+            raise RuntimeError("Frobby reported an error:\n" + err)
+
+        return output
+
+    def alexander_dual(self, monomial_ideal):
+        r"""
+        This function computes the Alexander dual of the passed-in
+        monomial ideal. This ideal is the one corresponding to the
+        simplicial complex whose faces are the complements of the
+        nonfaces of the simplicial complex corresponding to the input
+        ideal.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- the monomial ideal to decompose
+
+        OUTPUT: the monomial corresponding to the Alexander dual
+
+        EXAMPLES:
+
+        This is a simple example of computing irreducible decomposition. ::
+
+            sage: # optional - frobby
+            sage: (a, b, c, d) = QQ['a,b,c,d'].gens()
+            sage: id = ideal(a * b, b * c, c * d, d * a)
+            sage: alexander_dual = frobby.alexander_dual(id)
+            sage: true_alexander_dual = ideal(b * d, a * c)
+            sage: alexander_dual == true_alexander_dual # use sets to ignore order
+            True
+
+        We see how it is much faster to compute this with frobby than the built-in
+        procedure for simplicial complexes::
+
+            sage: # optional - frobby
+            sage: t=simplicial_complexes.PoincareHomologyThreeSphere()
+            sage: R=PolynomialRing(QQ,16,'x')
+            sage: I=R.ideal([prod([R.gen(i-1) for i in a]) for a in t.facets()])
+            sage: len(frobby.alexander_dual(I).gens())
+            643
+        """
+        frobby_input = self._ideal_to_string(monomial_ideal)
+        frobby_output = self('alexdual', input=frobby_input)
+        return self._parse_ideals(frobby_output, monomial_ideal.ring())[0]
+
+    def hilbert(self, monomial_ideal):
+        r"""
+        Compute the multigraded Hilbert-Poincaré series of the input
+        ideal. Use the -univariate option to get the univariate series.
+
+        The Hilbert-Poincaré series of a monomial ideal is the sum of all
+        monomials not in the ideal. This sum can be written as a (finite)
+        rational function with `(x_1-1)(x_2-1)...(x_n-1)` in the denominator,
+        assuming the variables of the ring are `x_1,x2,...,x_n`. This action
+        computes the polynomial in the numerator of this fraction.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- a monomial ideal
+
+        OUTPUT:
+
+        A polynomial in the same ring as the ideal.
+
+        EXAMPLES::
+
+            sage: R.<d,b,c>=QQ[] # optional - frobby
+            sage: I=[d*b*c,b^2*c,b^10,d^10]*R # optional - frobby
+            sage: frobby.hilbert(I) # optional - frobby
+            d^10*b^10*c + d^10*b^10 + d^10*b*c + b^10*c + d^10 + b^10 + d*b^2*c + d*b*c + b^2*c + 1
+        """
+        frobby_input = self._ideal_to_string(monomial_ideal)
+        frobby_output = self('hilbert', input=frobby_input)
+        ring = monomial_ideal.ring()
+        lines = frobby_output.split('\n')
+        if lines[-1] == '':
+            lines.pop(-1)
+        if lines[-1] == '(coefficient)':
+            lines.pop(-1)
+        lines.pop(0)
+        resul = 0
+        for l in lines:
+            lis = [int(_) for _ in l.split()]
+            resul += lis[0]+prod([ring.gen(i)**lis[i+1] for i in range(len(lis)-1)])
+        return resul
+
+    def associated_primes(self, monomial_ideal):
+        r"""
+        This function computes the associated primes of the passed-in
+        monomial ideal.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- the monomial ideal to decompose
+
+        OUTPUT:
+
+        A list of the associated primes of the monomial ideal. These ideals
+        are constructed in the same ring as monomial_ideal is.
+
+        EXAMPLES::
+
+            sage: R.<d,b,c>=QQ[] # optional - frobby
+            sage: I=[d*b*c,b^2*c,b^10,d^10]*R # optional - frobby
+            sage: frobby.associated_primes(I)   # optional - frobby
+            [Ideal (d, b) of Multivariate Polynomial Ring in d, b, c over Rational Field,
+            Ideal (d, b, c) of Multivariate Polynomial Ring in d, b, c over Rational Field]
+        """
+        frobby_input = self._ideal_to_string(monomial_ideal)
+        frobby_output = self('assoprimes', input=frobby_input)
+        lines = frobby_output.split('\n')
+        lines.pop(0)
+        if lines[-1] == '':
+            lines.pop(-1)
+        lists = [[int(_) for _ in a.split()] for a in lines]
+
+        def to_monomial(exps):
+            return [v ** e for v, e in zip(monomial_ideal.ring().gens(), exps) if e != 0]
+        return [monomial_ideal.ring().ideal(to_monomial(a)) for a in lists]
+
+    def dimension(self, monomial_ideal):
+        r"""
+        This function computes the dimension of the passed-in
+        monomial ideal.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- the monomial ideal to decompose
+
+        OUTPUT: the dimension of the zero set of the ideal
+
+        EXAMPLES::
+
+            sage: R.<d,b,c>=QQ[] # optional - frobby
+            sage: I=[d*b*c,b^2*c,b^10,d^10]*R # optional - frobby
+            sage: frobby.dimension(I)   # optional - frobby
+            1
+        """
+        frobby_input = self._ideal_to_string(monomial_ideal)
+        frobby_output = self('dimension', input=frobby_input)
+        return int(frobby_output)
+
+    def irreducible_decomposition(self, monomial_ideal):
+        r"""
+        This function computes the irreducible decomposition of the passed-in
+        monomial ideal. I.e. it computes the unique minimal list of
+        irreducible monomial ideals whose intersection equals monomial_ideal.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- the monomial ideal to decompose
+
+        OUTPUT:
+
+        A list of the unique irredundant irreducible components of
+        monomial_ideal. These ideals are constructed in the same ring
+        as monomial_ideal is.
+
+        EXAMPLES:
+
+        This is a simple example of computing irreducible decomposition. ::
+
+            sage: # optional - frobby
+            sage: (x, y, z) = QQ['x,y,z'].gens()
+            sage: id = ideal(x ** 2, y ** 2, x * z, y * z)
+            sage: decom = frobby.irreducible_decomposition(id)
+            sage: true_decom = [ideal(x, y), ideal(x ** 2, y ** 2, z)]
+            sage: set(decom) == set(true_decom) # use sets to ignore order
+            True
+
+        We now try the special case of the zero ideal in different rings.
+
+        We should also try PolynomialRing(QQ, names=[]), but it has a bug
+        which makes that impossible (see :issue:`3028`). ::
+
+            sage: # optional - frobby
+            sage: rings = [ZZ['x'], CC['x,y']]
+            sage: allOK = True
+            sage: for ring in rings:
+            ....:     id0 = ring.ideal(0)
+            ....:     decom0 = frobby.irreducible_decomposition(id0)
+            ....:     allOK = allOK and decom0 == [id0]
+            sage: allOK
+            True
+
+        Finally, we try the ideal that is all of the ring in different
+        rings. ::
+
+            sage: # optional - frobby
+            sage: rings = [ZZ['x'], CC['x,y']]
+            sage: allOK = True
+            sage: for ring in rings:
+            ....:     id1 = ring.ideal(1)
+            ....:     decom1 = frobby.irreducible_decomposition(id1)
+            ....:     allOK = allOK and decom1 == [id1]
+            sage: allOK
+            True
+        """
+        frobby_input = self._ideal_to_string(monomial_ideal)
+        frobby_output = self('irrdecom', input=frobby_input)
+        return self._parse_ideals(frobby_output, monomial_ideal.ring())
+
+    def _parse_ideals(self, string, ring):
+        r"""
+        This function parses a list of irreducible monomial ideals in 4ti2
+        format and constructs them within the passed-in ring.
+
+        INPUT:
+
+        - ``string`` -- the string to be parsed
+        - ``ring`` -- the ring within which to construct the irreducible
+          monomial ideals within
+
+        OUTPUT:
+
+        A list of the monomial ideals in the order they are listed
+        in the string.
+
+        EXAMPLES::
+
+            sage: # optional - frobby
+            sage: ring = QQ['x,y,z']
+            sage: (x, y, z) = ring.gens()
+            sage: string = '2 3\n1 2 3\n0 5 0\n2 3\n1 2 3\n4 5 6'
+            sage: frobby._parse_ideals(string, ring)
+            [Ideal (x*y^2*z^3, y^5) of Multivariate Polynomial Ring in x, y, z over Rational Field,
+            Ideal (x*y^2*z^3, x^4*y^5*z^6) of Multivariate Polynomial Ring in x, y, z over Rational Field]
+        """
+        lines = string.split('\n')
+        if lines[-1] == '':
+            lines.pop(-1)
+        matrices = []
+        while lines:
+            if lines[0].split()[1] == 'ring':
+                lines.pop(0)
+                lines.pop(0)
+                matrices.append('1 '+str(ring.ngens())+'\n'+'0 '*ring.ngens()+'\n')
+            else:
+                nrows = int(lines[0].split()[0])
+                nmatrix = lines.pop(0)+'\n'
+                for i in range(nrows):
+                    nmatrix += lines.pop(0)+'\n'
+                matrices.append(nmatrix)
+
+        def to_ideal(exps):
+            if len(exps) == 0:
+                return ring.zero_ideal()
+            gens = [prod([v ** e for v, e in zip(ring.gens(), expo) if e != 0]) for expo in exps]
+            return ring.ideal(gens or ring(1))
+        return [to_ideal(self._parse_4ti2_matrix(a)) for a in matrices] or [ring.ideal()]
+
+    def _parse_4ti2_matrix(self, string):
+        r"""
+        Parses a string of a matrix in 4ti2 format into a nested list
+        representation.
+
+        INPUT:
+
+        - ``string`` -- the string to be parsed
+
+        OUTPUT:
+
+        A list of rows of the matrix, where each row is represented as
+        a list of integers.
+
+        EXAMPLES:
+
+        The format is straight-forward, as this example shows. ::
+
+            sage: # optional - frobby
+            sage: string = '2 3\n1 2  3\n  0 5 0'
+            sage: parsed_matrix = frobby._parse_4ti2_matrix(string)
+            sage: reference_matrix = [[1, 2, 3], [0, 5, 0]]
+            sage: parsed_matrix == reference_matrix
+            True
+
+        A number of syntax errors lead to exceptions. ::
+
+            sage: string = '1 1\n one' # optional - frobby
+            sage: frobby._parse_4ti2_matrix(string) # optional - frobby
+            Traceback (most recent call last):
+            ...
+            RuntimeError: Format error: encountered non-number.
+        """
+        try:
+            ints = [int(_) for _ in string.split()]
+        except ValueError:
+            raise RuntimeError("Format error: encountered non-number.")
+        if len(ints) < 2:
+            raise RuntimeError("Format error: " +
+                               "matrix dimensions not specified.")
+
+        term_count = ints[0]
+        var_count = ints[1]
+        ints = ints[2:]
+
+        if term_count * var_count != len(ints):
+            raise RuntimeError("Format error: incorrect matrix dimensions.")
+
+        exponents = []
+        for i in range(term_count):
+            exponents.append(ints[:var_count])
+            ints = ints[var_count:]
+        return exponents
+
+    def _ideal_to_string(self, monomial_ideal):
+        r"""
+        This function formats the passed-in monomial ideal in 4ti2 format.
+
+        INPUT:
+
+        - ``monomial_ideal`` -- the monomial ideal to be formatted as a string
+
+        OUTPUT: string in ``4ti2`` format representing the ideal
+
+        EXAMPLES::
+
+            sage: # optional - frobby
+            sage: ring = QQ['x,y,z']
+            sage: (x, y, z) = ring.gens()
+            sage: id = ring.ideal(x ** 2, x * y * z)
+            sage: frobby._ideal_to_string(id) == "2 3\n2 0 0\n1 1 1\n"
+            True
+        """
+        # There is no exponent vector that represents zero as a generator, so
+        # we take care that the zero ideal gets represented correctly in the
+        # 4ti2 format; as an ideal with no generators.
+        if monomial_ideal.is_zero():
+            gens = []
+        else:
+            gens = monomial_ideal.gens()
+        var_count = monomial_ideal.ring().ngens()
+        first_row = str(len(gens)) + ' ' + str(var_count) + '\n'
+        rows = [self._monomial_to_string(_) for _ in gens]
+        return first_row + "".join(rows)
+
+    def _monomial_to_string(self, monomial):
+        r"""
+        This function formats the exponent vector of a monomial as a string
+        containing a space-delimited list of integers.
+
+        INPUT:
+
+        - ``monomial`` -- the monomial whose exponent vector is to be formatted
+
+        OUTPUT: string representing the exponent vector of monomial
+
+        EXAMPLES::
+
+            sage: # optional - frobby
+            sage: ring = QQ['x,y,z']
+            sage: (x, y, z) = ring.gens()
+            sage: monomial = x * x * z
+            sage: frobby._monomial_to_string(monomial) == '2 0 1\n'
+            True
+        """
+        exponents = monomial.exponents()
+        if len(exponents) != 1:
+            raise RuntimeError(str(monomial) + " is not a monomial.")
+        exponents = exponents[0]
+
+        # for a multivariate ring exponents will be an ETuple, while
+        # for a univariate ring exponents will be just an int. To get
+        # this to work we make the two cases look alike.
+        if isinstance(exponents, int):
+            exponents = [exponents]
+        strings = [str(exponents[var]) for var in range(len(exponents))]
+        return ' '.join(strings) + '\n'
+
+
+# This singleton instance is what should be used outside this file.
+frobby = Frobby()

sage/libs/all__sagemath_frobby.py

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