passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage/misc/all__sagemath_modules.py

@@ -0,0 +1,20 @@
+# sage_setup: distribution = sagemath-modules
+# All of sage.misc.all except for development tools, session management,
+# and deprecated functionality
+
+from sage.misc.lazy_attribute import lazy_attribute, lazy_class_attribute
+
+from sage.misc.all__sagemath_categories import *
+
+from sage.misc.misc import (BackslashOperator,               # Depends on sage.env -- can lower to sagemath-objects after splitting this module
+                            exists, forall, is_iterator,
+                            random_sublist,
+                            pad_zeros,
+                            newton_method_sizes, compose,
+                            nest)
+
+from sage.misc.temporary_file import tmp_dir, tmp_filename  # Depends on sage.env
+
+from sage.misc.mathml import mathml
+
+from sage.misc.func_persist import func_persist

sage/misc/c3.pyx

@@ -0,0 +1,238 @@
+# sage_setup: distribution = sagemath-modules
+"""
+The C3 algorithm
+
+The C3 algorithm is used as method resolution order for new style
+classes in Python. The implementation here is used to order the list
+of super categories of a category.
+
+AUTHOR:
+
+- Simon King (2011-11): initial version.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2011 Simon King <simon.king@uni-jena.de>
+#
+# 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/
+# ****************************************************************************
+
+
+cpdef list C3_algorithm(object start, str bases, str attribute, bint proper):
+    """
+    An implementation of the C3 algorithm.
+
+    C3 is the algorithm used by Python to construct the method
+    resolution order for new style classes involving multiple
+    inheritance.
+
+    After :issue:`11943` this implementation was used to compute the
+    list of super categories of a category; see
+    :meth:`~sage.categories.category.Category.all_super_categories`.
+    The purpose is to ensure that list of super categories matches
+    with the method resolution order of the parent or element classes
+    of a category.
+
+    Since :issue:`13589`, this implementation is superseded by that in
+    :mod:`sage.misc.c3_controlled`, that puts the ``C3`` algorithm
+    under control of some total order on categories.  This guarantees
+    that ``C3`` always finds a consistent Method Resolution Order. For
+    background, see :mod:`sage.misc.c3_controlled`.
+
+    INPUT:
+
+    - ``start`` -- an object; the returned list is built upon data
+      provided by certain attributes of ``start``
+    - ``bases`` -- string; the name of an attribute of ``start``
+      providing a list of objects
+    - ``attribute`` -- string; the name of an attribute of the
+      objects provided in ``getattr(start,bases)``. That attribute is
+      supposed to provide a list.
+
+    ASSUMPTIONS:
+
+    Our implementation of the algorithm only works on lists of
+    objects that compare equal if and only if they are identical.
+
+    OUTPUT:
+
+    A list, the result of the C3 algorithm applied to the list
+    ``[getattr(X,attribute) for X in getattr(start,bases)]``.
+
+    EXAMPLES:
+
+    We create a class for elements in a hierarchy that uses the ``C3``
+    algorithm to compute, for each element, a linear extension of the
+    elements above it::
+
+    .. TODO:: Move back the __init__ at the beginning
+
+        sage: from sage.misc.c3 import C3_algorithm
+        sage: class HierarchyElement(UniqueRepresentation):
+        ....:     @lazy_attribute
+        ....:     def _all_bases(self):
+        ....:         return C3_algorithm(self, '_bases', '_all_bases', False)
+        ....:     def __repr__(self):
+        ....:         return self._name
+        ....:     def __init__(self, name, bases):
+        ....:         self._name = name
+        ....:         self._bases = list(bases)
+
+    We construct a little hierarchy::
+
+        sage: T = HierarchyElement("T", ())
+        sage: X = HierarchyElement("X", (T,))
+        sage: Y = HierarchyElement("Y", (T,))
+        sage: A = HierarchyElement("A", (X, Y))
+        sage: B = HierarchyElement("B", (Y, X))
+        sage: Foo = HierarchyElement("Foo", (A, B))
+
+    And inspect the linear extensions associated to each element::
+
+        sage: T._all_bases
+        [T]
+        sage: X._all_bases
+        [X, T]
+        sage: Y._all_bases
+        [Y, T]
+        sage: A._all_bases
+        [A, X, Y, T]
+        sage: B._all_bases
+        [B, Y, X, T]
+
+    So far so good. However::
+
+        sage: Foo._all_bases
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot merge the items X, Y.
+
+    The ``C3`` algorithm is not able to create a consistent linear
+    extension. Indeed, its specifications impose that, if ``X`` and
+    ``Y`` appear in a certain order in the linear extension for an
+    element of the hierarchy, then they should appear in the same
+    order for any lower element. This is clearly not possibly for
+    ``Foo``, since ``A`` and ``B`` impose incompatible orders. If the
+    above was a hierarchy of classes, Python would complain that it
+    cannot calculate a consistent Method Resolution Order.
+
+    TESTS:
+
+    Regression test for bug #1 of :issue:`13501`::
+
+        sage: class C(): pass
+        sage: class F(): pass
+        sage: class G(): pass
+        sage: class B(C,F):    pass
+        sage: class D(F,G):    pass
+        sage: class E(F):      pass
+        sage: class A(B,D,E):  pass
+        sage: [cls.__name__ for cls in A.mro()]
+        ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'object']
+
+        sage: C = HierarchyElement("C", ())
+        sage: F = HierarchyElement("F", ())
+        sage: G = HierarchyElement("G", ())
+        sage: B = HierarchyElement("B", (C, F))
+        sage: D = HierarchyElement("D", (F, G))
+        sage: E = HierarchyElement("E", (F,))
+        sage: A = HierarchyElement("A", (B, D, E))
+        sage: A._all_bases
+        [A, B, C, D, E, F, G]
+
+    Regression test for bug #2 of :issue:`13501`. The following should
+    fail since ``A`` asks for ``B`` to come before ``C``, where as
+    ``B`` is a super class of ``C``::
+
+        sage: class B(): pass
+        sage: class C(B): pass
+        sage: class A(B, C): pass
+        Traceback (most recent call last):
+        ...
+        TypeError: ...Cannot create a consistent method resolution order (MRO)
+        for bases ...
+
+        sage: B = HierarchyElement("B", ())
+        sage: C = HierarchyElement("C", (B,))
+        sage: A = HierarchyElement("A", (B,C))
+        sage: A._all_bases
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot merge the items B, C, B.
+
+    Since :issue:`11943`, the following consistency tests are part
+    of the test suites of categories (except for hom categories)::
+
+        sage: C = Category.join([HopfAlgebrasWithBasis(QQ), FiniteEnumeratedSets()])
+        sage: C.parent_class.mro() == [x.parent_class for x in C.all_super_categories()]+[object]
+        True
+        sage: C.element_class.mro() == [x.element_class for x in C.all_super_categories()]+[object]
+        True
+    """
+    cdef list out
+    if proper:
+        out = []
+    else:
+        out = [start]
+    cdef list args = getattr(start, bases)
+    if not args:
+        return out
+    # Data structure / invariants:
+    # We will be working with the MRO's of the super objects
+    # together with the list of bases of ``self``.
+    # Each list is split between its head (in ``heads``) and tail (in
+    # ``tails'') . Each tail is stored reversed, so that we can use a
+    # cheap pop() in lieue of pop(0). A duplicate of the tail is
+    # stored as a set in ``tailsets`` for cheap membership testing.
+    # Since we actually want comparison by identity, not equality,
+    # what we store is the set of memory locations of objects
+    cdef object O, X
+    cdef list tails = [getattr(obj, attribute) for obj in args]
+    tails.append(args)
+    tails = [list(reversed(tail)) for tail in tails]
+    cdef list heads = [tail.pop() for tail in tails]
+    cdef list tailsets = [set([<size_t><void *>O for O in tail])
+                          for tail in tails]
+
+    cdef int i, j, nbheads
+    nbheads = len(heads)
+    cdef bint next_item_found
+    cdef list tail_list
+
+    while nbheads:
+        for i from 0 <= i < nbheads:
+            O = heads[i]
+            # Does O appear in none of the tails?  ``all(O not in tail for tail in tailsets)``
+            next_item_found = True
+            for j from 0 <= j < nbheads:
+                if j == i:
+                    continue
+                if <size_t><void *>O in <set>tailsets[j]:
+                    next_item_found = False
+                    break
+            if next_item_found:
+                out.append(O)
+                # Clear O from other heads, removing the line altogether
+                # if the tail is already empty.
+                # j goes down so that ``del heads[j]`` does not screw up the numbering
+                for j from nbheads > j >= 0:
+                    if heads[j] is O:
+                        tail_list = tails[j]
+                        if tail_list:
+                            X = tail_list.pop()
+                            heads[j] = X
+                            <set>tailsets[j].remove(<size_t><void *>X)
+                        else:
+                            del heads[j]
+                            del tails[j]
+                            del tailsets[j]
+                            nbheads -= 1
+                break
+        if not next_item_found:
+            # No head is available
+            raise ValueError("Cannot merge the items {}.".format(', '.join([repr(head) for head in heads])))
+    return out

sage/misc/compat.py

@@ -0,0 +1,87 @@
+# sage_setup: distribution = sagemath-modules
+"""Cross-platform compatibility routines and wrappers."""
+
+# *****************************************************************************
+#       Copyright (C) 2017 William Stein <wstein@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.
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+import os
+import sys
+
+from sage.env import SAGE_LOCAL
+
+
+#################################################################
+# Replacements (as needed) for Python stdlib functions to provide
+# better platform compatibility
+#################################################################
+if sys.platform == 'darwin':
+    # On OSX non-standard library paths are not automatically found by the
+    # find_library implementation without setting DYLD_LIBRARY_PATH; see
+    # https://github.com/sagemath/sage/issues/21399#comment:25
+    from ctypes.util import find_library as _orig_find_library
+
+    def _find_library(name):
+        libdirs = []
+        if SAGE_LOCAL:
+            libdirs.append(os.path.join(SAGE_LOCAL, 'lib'))
+        orig_dyld_library_path = os.environ.get('DYLD_LIBRARY_PATH')
+        try:
+            if libdirs:
+                colon_sep_path = ':'.join(libdirs)
+                if orig_dyld_library_path:
+                    colon_sep_path += ":" + orig_dyld_library_path
+                os.environ['DYLD_LIBRARY_PATH'] = colon_sep_path
+
+            return _orig_find_library(name)
+        finally:
+            if libdirs:
+                # Set os.environ back to what it was
+                if orig_dyld_library_path is not None:
+                    os.environ['DYLD_LIBRARY_PATH'] = orig_dyld_library_path
+                else:
+                    os.environ.pop('DYLD_LIBRARY_PATH', None)
+else:
+    # On other Unix-like platforms, at least where gcc is available,
+    # ctypes.util.find_library works, because it takes into account where gcc
+    # finds the library as if were being linked with
+    from ctypes.util import find_library as _find_library
+
+
+def find_library(name):
+    """
+    Return the shared library filename for a given library.
+
+    The library name is given without any prefixes or suffixes--(e.g.
+    just "Singular", not "libSingular", as shared library naming is
+    platform-specific.
+
+    This does ''not'' currently return the absolute path of the file on most
+    platforms; see https://bugs.python.org/issue21042
+
+    EXAMPLES::
+
+        sage: from sage.misc.compat import find_library
+        sage: find_library('giac')                                                      # needs sage.libs.giac
+        '...giac...'
+    """
+
+    result = _find_library(name)
+    if result:
+        return result
+
+    # if no result found, check DYLD_LIBRARY_PATH
+    LDPATH_STR = os.environ.get('DYLD_LIBRARY_PATH')
+    lib_dirs = (LDPATH_STR.split(':') if LDPATH_STR else []) + [os.path.join(SAGE_LOCAL, 'lib')]
+    for libdir in lib_dirs:
+        for libext in ['so', 'a']:
+            implib = os.path.join(libdir,
+                                  'lib{0}.{1}'.format(name, libext))
+            if os.path.exists(implib):
+                return implib

sage/misc/element_with_label.py

@@ -0,0 +1,173 @@
+# sage_setup: distribution = sagemath-modules
+r"""
+Elements with labels.
+
+This module implements a simple wrapper class for pairs consisting of
+an "element" and a "label".
+For representation purposes (``repr``, ``str``, ``latex``), this pair
+behaves like its label, while the element is "silent".
+However, these pairs compare like usual pairs (i.e., both element and
+label have to be equal for two such pairs to be equal).
+This is used for visual representations of graphs and posets
+with vertex labels.
+"""
+
+from sage.misc.latex import latex
+
+
+class ElementWithLabel:
+    """
+    Auxiliary class for showing/viewing :class:`Poset`s with
+    non-injective labelings.
+    For hashing and equality testing the resulting object behaves
+    like a tuple ``(element, label)``.
+    For any presentation purposes it appears just as ``label`` would.
+
+    EXAMPLES::
+
+        sage: # needs sage.combinat sage.graphs
+        sage: P = Poset({1: [2,3]})
+        sage: labs = {i: P.rank(i) for i in range(1, 4)}
+        sage: print(labs)
+        {1: 0, 2: 1, 3: 1}
+        sage: print(P.plot(element_labels=labs))                                        # needs sage.plot
+        Graphics object consisting of 6 graphics primitives
+
+        sage: # needs sage.combinat sage.graphs sage.modules
+        sage: from sage.misc.element_with_label import ElementWithLabel
+        sage: W = WeylGroup("A1")
+        sage: P = W.bruhat_poset(facade=True)
+        sage: D = W.domain()
+        sage: v = D.rho() - D.fundamental_weight(1)
+        sage: nP = P.relabel(lambda w: ElementWithLabel(w, w.action(v)))
+        sage: list(nP)
+        [(0, 0), (0, 0)]
+    """
+    def __init__(self, element, label):
+        """
+        Construct an object that wraps ``element`` but presents itself
+        as ``label``.
+
+        TESTS::
+
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: e = ElementWithLabel(1, 'a')
+            sage: e
+            'a'
+            sage: e.element
+            1
+        """
+        self.element = element
+        self.label = label
+
+    def _latex_(self):
+        """
+        Return the latex representation of ``self``,
+        which is just the latex representation of the label.
+
+        TESTS::
+
+            sage: var('a_1')                                                            # needs sage.symbolic
+            a_1
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: e = ElementWithLabel(1, a_1)                                          # needs sage.symbolic
+            sage: latex(e)                                                              # needs sage.symbolic
+            a_{1}
+        """
+        return latex(self.label)
+
+    def __str__(self):
+        """
+        Return the string representation of ``self``, which is just
+        the string representation of the label.
+
+        TESTS::
+
+            sage: var('a_1')                                                            # needs sage.symbolic
+            a_1
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: e = ElementWithLabel(1, a_1)                                          # needs sage.symbolic
+            sage: str(e)                                                                # needs sage.symbolic
+            'a_1'
+        """
+        return str(self.label)
+
+    def __repr__(self):
+        """
+        Return the representation of ``self``, which is just
+        the representation of the label.
+
+        TESTS::
+
+            sage: var('a_1')                                                            # needs sage.symbolic
+            a_1
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: e = ElementWithLabel(1, a_1)                                          # needs sage.symbolic
+            sage: repr(e)                                                               # needs sage.symbolic
+            'a_1'
+        """
+        return repr(self.label)
+
+    def __hash__(self):
+        """
+        Return the hash of the labeled element ``self``,
+        which is just the hash of ``self.element``.
+
+        TESTS::
+
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: a = ElementWithLabel(1, 'a')
+            sage: b = ElementWithLabel(1, 'b')
+            sage: d = {}
+            sage: d[a] = 'element 1'
+            sage: d[b] = 'element 2'
+            sage: print(d)
+            {'a': 'element 1', 'b': 'element 2'}
+            sage: a = ElementWithLabel("a", [2,3])
+            sage: hash(a) == hash(a.element)
+            True
+        """
+        return hash(self.element)
+
+    def __eq__(self, other):
+        """
+        Two labeled elements are equal if and only if both of their
+        constituents are equal.
+
+        TESTS::
+
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: a = ElementWithLabel(1, 'a')
+            sage: b = ElementWithLabel(1, 'b')
+            sage: x = ElementWithLabel(1, 'a')
+            sage: a == b
+            False
+            sage: a == x
+            True
+            sage: 1 == a
+            False
+            sage: b == 1
+            False
+        """
+        if not (isinstance(self, ElementWithLabel) and
+                isinstance(other, ElementWithLabel)):
+            return False
+        return self.element == other.element and self.label == other.label
+
+    def __ne__(self, other):
+        """
+        Two labeled elements are not equal if and only if first or second
+        constituents are not equal.
+
+        TESTS::
+
+            sage: from sage.misc.element_with_label import ElementWithLabel
+            sage: a = ElementWithLabel(1, 'a')
+            sage: b = ElementWithLabel(1, 'b')
+            sage: x = ElementWithLabel(1, 'a')
+            sage: a != b
+            True
+            sage: a != x
+            False
+        """
+        return not (self == other)

sage/misc/func_persist.py

@@ -0,0 +1,79 @@
+# sage_setup: distribution = sagemath-modules
+r"""
+Support for persistent functions in .sage files
+
+Persistent functions are functions whose values are stored on disk
+so they do not have to be recomputed.
+
+The inputs to the function must be hashable (so lists are not
+allowed). Though a hash is used, in the incredibly unlikely event
+that a hash collision occurs, your function will not return an
+incorrect result because of this (though the cache might not be
+used either).
+
+This is meant to be used from ``.sage`` files, not from
+library ``.py`` files.
+
+To use this disk caching mechanism, just put
+``@func_persist`` right before your function
+definition. For example,
+
+::
+
+    @func_persist
+    def bern(n):
+        "Return the n-th Bernoulli number, caching the result to disk."
+        return bernoulli(n)
+
+You can then use the function ``bern`` as usual, except
+it will almost instantly return values that have already been
+computed, even if you quit and restart.
+
+The disk cache files are stored by default in the subdirectory
+``func_persist`` of the current working directory,
+with one file for each evaluation of the function.
+"""
+########################################################################
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+########################################################################
+
+import inspect
+import os
+
+from sage.misc import persist
+
+
+class func_persist:
+    r"""
+    Put ``@func_persist`` right before your function
+    definition to cache values it computes to disk.
+    """
+    def __init__(self, f, dir='func_persist'):
+        self.__func = f
+        self.__dir = dir
+        os.makedirs(dir, exist_ok=True)
+        self.__doc__ = '%s%s%s' % (
+            f.__name__,
+            inspect.signature(f),
+            f.__doc__)
+
+    def __call__(self, *args, **kwds):
+        key = (tuple(args), tuple(kwds.items()))
+        h = hash(key)
+        name = '%s/%s_%s.sobj' % (self.__dir, self.__func.__name__, h)
+
+        if os.path.exists(name):
+            key2, val = persist.load(name)
+            if key == key2:
+                # We save and test equality of keys to avoid
+                # the (extremely remote) possibility of a hash
+                # collision.  Correctness is crucial in mathematics.
+                return val
+
+        val = self.__func(*args, **kwds)
+        persist.save((key, val), name)
+        return val

sage/misc/pickle_old.pyx

@@ -0,0 +1,19 @@
+# sage_setup: distribution = sagemath-modules
+
+from sage.misc.superseded import deprecation_cython as deprecation
+import sage.rings.fraction_field_element
+
+
+def make_element_old(_class, _dict, parent):
+    """
+    Used for unpickling old pickles of Element objects (and subclasses).
+
+    This function is deprecated and is kept only to support old pickles.
+    """
+    deprecation(4698, "Your data is stored in an old format. Please use the save() function to store your data in a more recent format.")
+    if _class is sage.rings.fraction_field_element.FractionFieldElement:
+        return sage.rings.fraction_field_element.make_element_old(parent, _dict)
+    new_object = _class.__new__(_class)
+    new_object._set_parent(parent)
+    new_object.__dict__ = _dict
+    return new_object

sage/misc/proof.py

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Whether or not computations are provably correct by default
+"""
+
+# proof = False
+proof = True