passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/rings/polynomial/ore_polynomial_ring.py

@@ -46,6 +46,7 @@ AUTHOR:
 #                  https://www.gnu.org/licenses/
 # ***************************************************************************
 
+import operator
 from sage.categories.algebras import Algebras
 from sage.categories.commutative_rings import CommutativeRings
 from sage.categories.morphism import Morphism
@@ -338,15 +339,17 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
             Univariate Polynomial Ring in x over Finite Field in a of size 5^2
             sage: S.<x> = OrePolynomialRing(k, Frob, polcast=False)
             sage: S
-            Ore Polynomial Ring in x over Finite Field in a of size 5^2 twisted by Identity
+            Ore Polynomial Ring in x over Finite Field in a of size 5^2 untwisted
         """
         if base_ring not in CommutativeRings():
             raise TypeError('base_ring must be a commutative ring')
-        if isinstance(twist, Morphism):
+        if twist is None:
+            morphism = derivation = None
+        elif isinstance(twist, Morphism):
             if (twist.domain() is not base_ring
              or twist.codomain() is not base_ring):
                 raise TypeError("the twisting morphism must be an endomorphism of base_ring (=%s)" % base_ring)
-            if twist.is_identity() and polcast:
+            if twist.is_identity():
                 morphism = None
             else:
                 morphism = twist
@@ -360,6 +363,8 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
                 derivation = twist
             else:
                 derivation = None
+        elif twist is None:
+            morphism = derivation = None
         else:
             raise TypeError("the twisting map must be a ring morphism or a derivation")
         if names is None:
@@ -621,6 +626,65 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
             if P.variable_name() == self.variable_name():
                 return base_ring.has_coerce_map_from(P.base_ring())
 
+    def _repr_twist(self):
+        r"""
+        Return a string representation of the twisting morphisms.
+
+        This is a helper method.
+
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: F.<z> = GF(5^3)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: S.<x> = OrePolynomialRing(F, Frob)
+            sage: S._repr_twist()
+            'twisted by z |--> z^5'
+            sage: T.<y> = OrePolynomialRing(F, Frob^3, polcast=False)
+            sage: T._repr_twist()
+            'untwisted'
+        """
+        s = ""
+        if self._morphism is not None:
+            s += self._morphism._repr_short()
+        if self._derivation is not None:
+            if s != "":
+                s += " and "
+            s += self._derivation._repr_()
+        if s == "":
+            return "untwisted"
+        else:
+            return "twisted by " + s
+
+    def _latex_twist(self):
+        r"""
+        Return a LaTeX representation of the twisting morphisms.
+
+        This is a helper method.
+
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: F.<z> = GF(5^3)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: S.<x> = OrePolynomialRing(F, Frob)
+            sage: S._latex_twist()
+            z \mapsto z^{5}
+            sage: T.<y> = OrePolynomialRing(F, Frob^3, polcast=False)
+            sage: T._latex_twist()
+            ''
+
+        """
+        from sage.misc.latex import latex
+        s = ""
+        if self._morphism is not None:
+            s += latex(self._morphism)
+        if self._derivation is not None:
+            if s != "":
+                s += ","
+            s += latex(self._derivation)
+        return s
+
     def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
@@ -638,13 +702,7 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
             sage: T
             Ore Polynomial Ring in d over Univariate Polynomial Ring in t over Rational Field twisted by d/dt
         """
-        s = "Ore Polynomial Ring in %s over %s twisted by " % (self.variable_name(), self.base_ring())
-        if self._derivation is None:
-            s += self._morphism._repr_short()
-        else:
-            if self._morphism is not None:
-                s += "%s and " % self._morphism._repr_short()
-            s += self._derivation._repr_()
+        s = "Ore Polynomial Ring in %s over %s %s" % (self.variable_name(), self.base_ring(), self._repr_twist())
         if self.is_sparse():
             s = "Sparse " + s
         return s
@@ -670,12 +728,9 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
         """
         from sage.misc.latex import latex
         s = "%s\\left[%s" % (latex(self.base_ring()), self.latex_variable_names()[0])
-        sep = ";"
-        if self._morphism is not None:
-            s += sep + latex(self._morphism)
-            sep = ","
-        if self._derivation is not None:
-            s += sep + latex(self._derivation)
+        twist = self._latex_twist()
+        if twist != "":
+            s += ";" + twist
         return s + "\\right]"
 
     def change_var(self, var):
@@ -704,7 +759,7 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
         else:
             twist = self._derivation
         return OrePolynomialRing(self.base_ring(), twist, names=var,
-                                 sparse=self.__is_sparse)
+                                 sparse=self.__is_sparse, polcast=False)
 
     def characteristic(self):
         r"""
@@ -1196,6 +1251,68 @@ class OrePolynomialRing(UniqueRepresentation, Parent):
                 self._fraction_field.register_coercion(self)
         return self._fraction_field
 
+    def quotient_module(self, P, names=None):
+        r"""
+        Return the quotient ring `A/AP` as a module over `A`
+        where `A` is this Ore polynomial ring.
+
+        INPUT:
+
+        - ``names`` (default: ``None``) -- a string or a list
+          of string, the names of the vector of the canonical
+          basis
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: k.<a> = GF(5^3)
+            sage: S.<x> = k['a', k.frobenius_endomorphism()]
+            sage: P = x^3 + a*x^2 + a^2 + 1
+            sage: M = S.quotient_module(P)
+            sage: M
+            Ore module of rank 3 over Finite Field in a of size 5^3 twisted by a |--> a^5
+
+        The argument ``names`` can be used to give chosen names
+        to the vectors in the canonical basis::
+
+            sage: M = S.quotient_module(P, names=('u', 'v', 'w'))                       # needs sage.rings.finite_rings
+            sage: M.basis()                                                             # needs sage.rings.finite_rings
+            [u, v, w]
+
+        or even::
+
+            sage: M = S.quotient_module(P, names='e')                                   # needs sage.rings.finite_rings
+            sage: M.basis()                                                             # needs sage.rings.finite_rings
+            [e0, e1, e2]
+
+        Note that the bracket construction also works::
+
+            sage: M.<u,v,w> = S.quotient_module(P)                                      # needs sage.rings.finite_rings
+            sage: M.basis()                                                             # needs sage.rings.finite_rings
+            [u, v, w]
+
+        With this construction, the vectors `u`, `v` and `w`
+        are directly available in the namespace::
+
+            sage: x*u + v                                                               # needs sage.rings.finite_rings
+            2*v
+
+        We refer to :mod:`sage.modules.ore_module` for a
+        tutorial on Ore modules in SageMath.
+
+        .. SEEALSO::
+
+            :mod:`sage.modules.ore_module`
+        """
+        from sage.matrix.special import companion_matrix
+        from sage.modules.ore_module import OreModule, OreAction
+        coeffs = self(P).right_monic().list()
+        f = companion_matrix(coeffs, format='bottom')
+        M = OreModule(f, self, names=names)
+        M._unset_coercions_used()
+        M.register_action(OreAction(self, M, True, operator.mul))
+        return M
+
     def _pushout_(self, other):
         r"""
         Return the pushout of this Ore polynomial ring and ``other``.

sage/rings/polynomial/skew_polynomial_finite_field.pyx

@@ -238,7 +238,7 @@ cdef class SkewPolynomial_finite_field_dense(SkewPolynomial_finite_order_dense):
         cdef Py_ssize_t i, j, t, r = skew_ring._order
         cdef Polynomial dd, xx, yy, zz
         cdef Integer exp
-        cdef list lM, lV
+        cdef list lM
         cdef bint char2
 
         center = parent(N)
@@ -755,13 +755,12 @@ cdef class SkewPolynomial_finite_field_dense(SkewPolynomial_finite_order_dense):
             del a[0]
             val += 1
 
-        cdef Py_ssize_t degQ, degrandom, m, mP, i
+        cdef Py_ssize_t degrandom, m, mP, i
         cdef N
         cdef list factors = [ (skew_ring.gen(), val) ]
         cdef SkewPolynomial_finite_field_dense P, Q, P1, NS, g, right, Pn
         cdef unit = self.leading_coefficient()
         cdef Polynomial gencenter = skew_ring._working_center.gen()
-        cdef Py_ssize_t p = skew_ring.characteristic()
         cdef F = self._reduced_norm_factored()
 
         for N, m in F:
@@ -947,7 +946,7 @@ cdef class SkewPolynomial_finite_field_dense(SkewPolynomial_finite_order_dense):
             (x + t^2 + 4) * (x + t + 3) * (x + t)
 
         However, the algorithm is probabilistic. Hence if we first
-        reinitialiaze `a`, we may get a different answer::
+        reinitialize `a`, we may get a different answer::
 
             sage: a = x^3 + (t^2 + 4*t + 2)*x^2 + (3*t + 3)*x + t^2 + 1
             sage: F = a.factor(); F   # random

sage/rings/polynomial/skew_polynomial_finite_order.pyx

@@ -132,7 +132,6 @@ cdef class SkewPolynomial_finite_order_dense(SkewPolynomial_generic_dense):
         cdef Py_ssize_t i, j, deb, k, r = self.parent()._order
         cdef Py_ssize_t d = self.degree ()
         cdef Parent base_ring = <Parent?>self.parent().base_ring()
-        cdef RingElement minusone = <RingElement?>base_ring(-1)
         cdef RingElement zero = <RingElement?>base_ring(0)
         cdef Polk = PolynomialRing (base_ring, 'xr')
         cdef list M = []
@@ -385,7 +384,7 @@ cdef class SkewPolynomial_finite_order_dense(SkewPolynomial_generic_dense):
         for more details about this).
         The user can speciify different names if desired::
 
-            sage: a.reduced_charpoly(var='T')  # variable name for the caracteristic polynomial
+            sage: a.reduced_charpoly(var='T')  # variable name for the characteristic polynomial
             T^3 + (2*z + 1)*T^2 + (3*z^2 + 4*z)*T + 4*z^3 + z^2 + 1
 
             sage: a.reduced_charpoly(var=('T', 'c'))
@@ -396,8 +395,6 @@ cdef class SkewPolynomial_finite_order_dense(SkewPolynomial_generic_dense):
             :meth:`reduced_trace`, :meth:`reduced_norm`
         """
         if self._charpoly is None:
-            parent = self._parent
-            section = parent._embed_constants.section()
             M = self._matmul_c()
             chi = M.charpoly()
             self._charpoly = [tuple(c.list()) for c in chi.list()]
@@ -407,7 +404,7 @@ cdef class SkewPolynomial_finite_order_dense(SkewPolynomial_generic_dense):
         if var is None:
             varcharpoly = 'x'
         elif isinstance(var, (tuple, list)) and len(var) == 2:
-            (varcharpoly, varcenter) = var
+            varcharpoly, varcenter = var
         else:
             varcharpoly = var
         center = self.parent().center(name=varcenter)

sage/rings/real_mpfr.pyx

@@ -906,16 +906,16 @@ cdef class RealField_class(sage.rings.abc.RealField):
         """
         return 1
 
-    def gens(self):
+    def gens(self) -> tuple:
         """
-        Return a list of generators.
+        Return a tuple of generators.
 
         EXAMPLES::
 
             sage: RR.gens()
-            [1.00000000000000]
+            (1.00000000000000,)
         """
-        return [self.gen()]
+        return (self.gen(),)
 
     def _is_valid_homomorphism_(self, codomain, im_gens, base_map=None):
         """
@@ -2656,7 +2656,7 @@ cdef class RealNumber(sage.structure.element.RingElement):
         return x
 
     # Bit shifting
-    def _lshift_(RealNumber self, n):
+    def _lshift_(RealNumber self, Integer n):
         """
         Return ``self * (2^n)`` for an integer ``n``.
 
@@ -2667,6 +2667,8 @@ cdef class RealNumber(sage.structure.element.RingElement):
             sage: RR(1.5)._lshift_(2)
             6.00000000000000
         """
+        if n < 0:
+            return self._rshift_(-n)
         cdef RealNumber x
         if n > sys.maxsize:
             raise OverflowError("n (=%s) must be <= %s" % (n, sys.maxsize))
@@ -2686,6 +2688,15 @@ cdef class RealNumber(sage.structure.element.RingElement):
             Traceback (most recent call last):
             ...
             TypeError: unsupported operands for <<
+
+        TESTS::
+
+            sage: 32r << 2.5
+            Traceback (most recent call last):
+            ...
+            TypeError: unsupported operands for <<
+            sage: 1.5 << -2
+            0.375000000000000
         """
         if not isinstance(x, RealNumber):
             raise TypeError("unsupported operands for <<")
@@ -2694,7 +2705,7 @@ cdef class RealNumber(sage.structure.element.RingElement):
         except TypeError:
             raise TypeError("unsupported operands for <<")
 
-    def _rshift_(RealNumber self, n):
+    def _rshift_(RealNumber self, Integer n):
         """
         Return ``self / (2^n)`` for an integer ``n``.
 
@@ -2705,6 +2716,8 @@ cdef class RealNumber(sage.structure.element.RingElement):
             sage: RR(1.5)._rshift_(2)
             0.375000000000000
         """
+        if n < 0:
+            return self._lshift_(-n)
         if n > sys.maxsize:
             raise OverflowError("n (=%s) must be <= %s" % (n, sys.maxsize))
         cdef RealNumber x = self._new()
@@ -2723,6 +2736,11 @@ cdef class RealNumber(sage.structure.element.RingElement):
             Traceback (most recent call last):
             ...
             TypeError: unsupported operands for >>
+
+        TESTS::
+
+            sage: 1.5 >> -2
+            6.00000000000000
         """
         if not isinstance(x, RealNumber):
             raise TypeError("unsupported operands for >>")
@@ -5399,7 +5417,7 @@ cdef class RealNumber(sage.structure.element.RingElement):
             sage: r.algebraic_dependency(5)                                             # needs fpylll
             x^2 - 2
         """
-        return sage.arith.misc.algdep(self, n)
+        return sage.arith.misc.algebraic_dependency(self, n)
 
     algdep = algebraic_dependency
 

sage/rings/ring_extension.pyx

@@ -111,6 +111,7 @@ AUTHOR:
 # ***************************************************************************
 
 
+cimport cython
 from sage.misc.fast_methods cimport hash_by_id
 from sage.misc.cachefunc import cached_method
 from sage.cpython.getattr cimport AttributeErrorMessage
@@ -613,6 +614,7 @@ cdef class RingExtension_generic(Parent):
         self.register_coercion(RingExtensionBackendIsomorphism(ring.Hom(self)))
         ring.register_conversion(RingExtensionBackendReverseIsomorphism(self.Hom(ring)))
 
+    @cython.binding(True)
     def __getattr__(self, name):
         """
         If this extension was created with ``import_methods = True``,
@@ -1315,7 +1317,7 @@ cdef class RingExtension_generic(Parent):
         elt = self._backend.an_element()
         return self.element_class(self, elt)
 
-    def gens(self, base=None):
+    def gens(self, base=None) -> tuple:
         r"""
         Return the generators of this extension over ``base``.
 
@@ -2662,7 +2664,7 @@ cdef class RingExtensionWithGen(RingExtensionWithBasis):
         S = PolynomialRing(self._base, name=var)
         return S(coeffs)
 
-    def gens(self, base=None):
+    def gens(self, base=None) -> tuple:
         r"""
         Return the generators of this extension over ``base``.
 

sage/rings/ring_extension_element.pyx

@@ -18,6 +18,7 @@ AUTHOR:
 # ***************************************************************************
 
 
+cimport cython
 from sage.ext.stdsage cimport PY_NEW
 from sage.cpython.getattr cimport AttributeErrorMessage
 from sage.cpython.getattr import dir_with_other_class
@@ -97,6 +98,7 @@ cdef class RingExtensionElement(CommutativeAlgebraElement):
         """
         return self._parent, (self._backend,)
 
+    @cython.binding(True)
     def __getattr__(self, name):
         """
         If the parent of this element was created with ``import_methods = True``,
@@ -130,6 +132,46 @@ cdef class RingExtensionElement(CommutativeAlgebraElement):
         wrapper.__doc__ = method.__doc__
         return wrapper
 
+    def __getitem__(self, i):
+        r"""
+        Return the `i`-th item of this element.
+
+        This methods calls the appropriate method of the backend if
+        ``import_methods`` is set to ``True``
+
+        EXAMPLES::
+
+            sage: R.<x> = QQ[]
+            sage: E = R.over()
+            sage: P = E(x^2 + 2*x + 3)
+            sage: P[0]
+            3
+        """
+        if (<RingExtension_generic>self._parent)._import_methods:
+            output = self._backend[to_backend(i)]
+            return from_backend(output, self._parent)
+        return TypeError("this element is not subscriptable")
+
+    def __call__(self, *args, **kwargs):
+        r"""
+        Call this element.
+
+        This methods calls the appropriate method of the backend if
+        ``import_methods`` is set to ``True``
+
+        EXAMPLES::
+
+            sage: R.<x> = QQ[]
+            sage: E = R.over()
+            sage: P = E(x^2 + 2*x + 3)
+            sage: P(1)
+            6
+        """
+        if (<RingExtension_generic>self._parent)._import_methods:
+            output = self._backend(*to_backend(args), **to_backend(kwargs))
+            return from_backend(output, self._parent)
+        return TypeError("this element is not callable")
+
     def __dir__(self):
         """
         Return the list of all the attributes of this element;

sage/schemes/all__sagemath_modules.py

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

sage/schemes/projective/all__sagemath_modules.py

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