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

sage/rings/complex_mpfr.pyx

@@ -619,7 +619,7 @@ class ComplexField_class(sage.rings.abc.ComplexField):
             return self._generic_coerce_map(S)
         return self._coerce_map_via([CLF], S)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 
@@ -630,9 +630,9 @@ class ComplexField_class(sage.rings.abc.ComplexField):
             sage: ComplexField(15) # indirect doctest
             Complex Field with 15 bits of precision
         """
-        return "Complex Field with %s bits of precision"%self._prec
+        return "Complex Field with %s bits of precision" % self._prec
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -1331,7 +1331,7 @@ cdef class ComplexNumber(sage.structure.element.FieldElement):
 
         INPUT:
 
-        - ``format_spec`` -- string; a floating point format specificier as
+        - ``format_spec`` -- string; a floating point format specifier as
           defined by :python:`the format specification mini-language
           <library/string.html#formatspec>` in Python
 
@@ -3259,8 +3259,10 @@ cdef class ComplexNumber(sage.structure.element.FieldElement):
 
         ALGORITHM: Uses the PARI C-library :pari:`algdep` command.
 
-        INPUT: Type ``algdep?`` at the top level prompt. All additional
-        parameters are passed onto the top-level :func:`algdep` command.
+        INPUT: Type ``algebraic_dependency?`` at the top level prompt.
+
+        All additional parameters are passed onto the top-level
+        :func:`algebraic_dependency` command.
 
         EXAMPLES::
 
@@ -3268,13 +3270,13 @@ cdef class ComplexNumber(sage.structure.element.FieldElement):
             sage: C = ComplexField()
             sage: z = (1/2)*(1 + sqrt(3.0) *C.0); z
             0.500000000000000 + 0.866025403784439*I
-            sage: p = z.algdep(5); p
+            sage: p = z.algebraic_dependency(5); p
             x^2 - x + 1
             sage: p(z)
             1.11022302462516e-16
         """
-        from sage.arith.misc import algdep
-        return algdep(self, n, **kwds)
+        from sage.arith.misc import algebraic_dependency
+        return algebraic_dependency(self, n, **kwds)
 
     # Alias
     algdep = algebraic_dependency

sage/rings/function_field/drinfeld_modules/charzero_drinfeld_module.py

@@ -3,14 +3,16 @@
 r"""
 Drinfeld modules over rings of characteristic zero
 
-This module provides the class
-:class:`sage.rings.function_fields.drinfeld_module.charzero_drinfeld_module.DrinfeldModule_charzero`,
-which inherits
+This module provides the classes
+:class:`sage.rings.function_fields.drinfeld_module.charzero_drinfeld_module.DrinfeldModule_charzero` and
+:class:`sage.rings.function_fields.drinfeld_module.charzero_drinfeld_module.DrinfeldModule_rational`,
+which both inherit
 :class:`sage.rings.function_fields.drinfeld_module.drinfeld_module.DrinfeldModule`.
 
 AUTHORS:
 
 - David Ayotte (2023-09)
+- Xavier Caruso (2024-12) - computation of class polynomials
 """
 
 # *****************************************************************************
@@ -26,11 +28,16 @@ AUTHORS:
 from .drinfeld_module import DrinfeldModule
 
 from sage.rings.integer_ring import ZZ
+from sage.rings.infinity import Infinity
+
+from sage.matrix.constructor import matrix
+from sage.modules.free_module_element import vector
 
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import lazy_import
 
 lazy_import('sage.rings.lazy_series_ring', 'LazyPowerSeriesRing')
+lazy_import('sage.rings.power_series_ring', 'PowerSeriesRing')
 
 
 class DrinfeldModule_charzero(DrinfeldModule):
@@ -150,7 +157,7 @@ class DrinfeldModule_charzero(DrinfeldModule):
             c += self._compute_coefficient_exp(i)*self._compute_coefficient_log(j)**(q**i)
         return -c
 
-    def exponential(self, name='z'):
+    def exponential(self, prec=Infinity, name='z'):
         r"""
         Return the exponential of this Drinfeld module.
 
@@ -159,28 +166,38 @@ class DrinfeldModule_charzero(DrinfeldModule):
 
         INPUT:
 
+        - ``prec`` -- an integer or ``Infinity`` (default: ``Infinity``);
+          the precision at which the series is returned; if ``Infinity``,
+          a lazy power series in returned, else, a classical power series
+          is returned.
+
         - ``name`` -- string (default: ``'z'``); the name of the
           generator of the lazy power series ring
 
-        OUTPUT: a lazy power series over the base field
-
         EXAMPLES::
 
             sage: A = GF(2)['T']
             sage: K.<T> = Frac(A)
             sage: phi = DrinfeldModule(A, [T, 1])
             sage: q = A.base_ring().cardinality()
-            sage: exp = phi.exponential(); exp
-            z + ((1/(T^2+T))*z^2) + ((1/(T^8+T^6+T^5+T^3))*z^4) + O(z^8)
 
-        The exponential is returned as a lazy power series, meaning that
-        any of its coefficients can be computed on demands::
+        When ``prec`` is ``Infinity`` (which is the default),
+        the exponential is returned as a lazy power series, meaning
+        that any of its coefficients can be computed on demands::
 
+            sage: exp = phi.exponential(); exp
+            z + ((1/(T^2+T))*z^2) + ((1/(T^8+T^6+T^5+T^3))*z^4) + O(z^8)
             sage: exp[2^4]
             1/(T^64 + T^56 + T^52 + ... + T^27 + T^23 + T^15)
             sage: exp[2^5]
             1/(T^160 + T^144 + T^136 + ... + T^55 + T^47 + T^31)
 
+        On the contrary, when ``prec`` is a finite number, all the
+        required coefficients are computed at once::
+
+            sage: phi.exponential(prec=10)
+            z + (1/(T^2 + T))*z^2 + (1/(T^8 + T^6 + T^5 + T^3))*z^4 + (1/(T^24 + T^20 + T^18 + T^17 + T^14 + T^13 + T^11 + T^7))*z^8 + O(z^10)
+
         Example in higher rank::
 
             sage: A = GF(5)['T']
@@ -217,7 +234,6 @@ class DrinfeldModule_charzero(DrinfeldModule):
         See section 4.6 of [Gos1998]_ for the definition of the
         exponential.
         """
-        L = LazyPowerSeriesRing(self._base, name)
         zero = self._base.zero()
         q = self._Fq.cardinality()
 
@@ -229,7 +245,12 @@ class DrinfeldModule_charzero(DrinfeldModule):
                 return self._compute_coefficient_exp(v)
             else:
                 return zero
-        return L(coeff_exp, valuation=1)
+
+        if prec is Infinity:
+            L = LazyPowerSeriesRing(self._base, name)
+            return L(coeff_exp, valuation=1)
+        L = PowerSeriesRing(self._base, name, default_prec=prec)
+        return L([0] + [coeff_exp(i) for i in range(1,prec)], prec=prec)
 
     @cached_method
     def _compute_coefficient_log(self, k):
@@ -265,7 +286,7 @@ class DrinfeldModule_charzero(DrinfeldModule):
                 c += self._compute_coefficient_log(i)*self._gen[j]**(q**i)
         return c/(T - T**(q**k))
 
-    def logarithm(self, name='z'):
+    def logarithm(self, prec=Infinity, name='z'):
         r"""
         Return the logarithm of the given Drinfeld module.
 
@@ -276,27 +297,36 @@ class DrinfeldModule_charzero(DrinfeldModule):
 
         INPUT:
 
+        - ``prec`` -- an integer or ``Infinity`` (default: ``Infinity``);
+          the precision at which the series is returned; if ``Infinity``,
+          a lazy power series in returned
+
         - ``name`` -- string (default: ``'z'``); the name of the
           generator of the lazy power series ring
 
-        OUTPUT: a lazy power series over the base field
-
         EXAMPLES::
 
             sage: A = GF(2)['T']
             sage: K.<T> = Frac(A)
             sage: phi = DrinfeldModule(A, [T, 1])
-            sage: log = phi.logarithm(); log
-            z + ((1/(T^2+T))*z^2) + ((1/(T^6+T^5+T^3+T^2))*z^4) + O(z^8)
 
-        The logarithm is returned as a lazy power series, meaning that
-        any of its coefficients can be computed on demands::
+        When ``prec`` is ``Infinity`` (which is the default),
+        the logarithm is returned as a lazy power series, meaning
+        that any of its coefficients can be computed on demands::
 
+            sage: log = phi.logarithm(); log
+            z + ((1/(T^2+T))*z^2) + ((1/(T^6+T^5+T^3+T^2))*z^4) + O(z^8)
             sage: log[2^4]
             1/(T^30 + T^29 + T^27 + ... + T^7 + T^5 + T^4)
             sage: log[2^5]
             1/(T^62 + T^61 + T^59 + ... + T^8 + T^6 + T^5)
 
+        If ``prec`` is a finite number, all the
+        required coefficients are computed at once::
+
+            sage: phi.logarithm(prec=10)
+            z + (1/(T^2 + T))*z^2 + (1/(T^6 + T^5 + T^3 + T^2))*z^4 + (1/(T^14 + T^13 + T^11 + T^10 + T^7 + T^6 + T^4 + T^3))*z^8 + O(z^10)
+
         Example in higher rank::
 
             sage: A = GF(5)['T']
@@ -318,7 +348,6 @@ class DrinfeldModule_charzero(DrinfeldModule):
             sage: log[2**3] == -1/((T**q - T)*(T**(q**2) - T)*(T**(q**3) - T))  # expected value
             True
         """
-        L = LazyPowerSeriesRing(self._base, name)
         q = self._Fq.cardinality()
 
         def coeff_log(k):
@@ -329,7 +358,12 @@ class DrinfeldModule_charzero(DrinfeldModule):
                 return self._compute_coefficient_log(v)
             else:
                 return self._base.zero()
-        return L(coeff_log, valuation=1)
+
+        if prec is Infinity:
+            L = LazyPowerSeriesRing(self._base, name)
+            return L(coeff_log, valuation=1)
+        L = PowerSeriesRing(self._base, name, default_prec=prec)
+        return L([0] + [coeff_log(i) for i in range(1, prec)], prec=prec)
 
     @cached_method
     def _compute_goss_polynomial(self, n, q, poly_ring, X):
@@ -415,3 +449,225 @@ class DrinfeldModule_charzero(DrinfeldModule):
         X = poly_ring.gen()
         q = self._Fq.cardinality()
         return self._compute_goss_polynomial(n, q, poly_ring, X)
+
+
+class DrinfeldModule_rational(DrinfeldModule_charzero):
+    """
+    A class for Drinfeld modules defined over the fraction
+    field of the underlying function field.
+
+    TESTS::
+
+        sage: q = 9
+        sage: Fq = GF(q)
+        sage: A = Fq['T']
+        sage: K.<T> = Frac(A)
+        sage: C = DrinfeldModule(A, [T, 1]); C
+        Drinfeld module defined by T |--> t + T
+        sage: type(C)
+        <class 'sage.rings.function_field.drinfeld_modules.charzero_drinfeld_module.DrinfeldModule_rational_with_category'>
+    """
+    def coefficient_in_function_ring(self, n):
+        r"""
+        Return the `n`-th coefficient of this Drinfeld module as
+        an element of the underlying function ring.
+
+        INPUT:
+
+        - ``n`` -- an integer
+
+        EXAMPLES::
+
+            sage: q = 5
+            sage: Fq = GF(q)
+            sage: A = Fq['T']
+            sage: R = Fq['U']
+            sage: K.<U> = Frac(R)
+            sage: phi = DrinfeldModule(A, [U, 0, U^2, U^3])
+            sage: phi.coefficient_in_function_ring(2)
+            T^2
+
+        Compare with the method meth:`coefficient`::
+
+            sage: phi.coefficient(2)
+            U^2
+
+        If the required coefficient is not a polynomials,
+        an error is raised::
+
+            sage: psi = DrinfeldModule(A, [U, 1/U])
+            sage: psi.coefficient_in_function_ring(0)
+            T
+            sage: psi.coefficient_in_function_ring(1)
+            Traceback (most recent call last):
+            ...
+            ValueError: coefficient is not polynomial
+        """
+        A = self.function_ring()
+        g = self.coefficient(n)
+        g = g.backend(force=True)
+        if g.denominator().is_one():
+            return A(g.numerator().list())
+        else:
+            raise ValueError("coefficient is not polynomial")
+
+    def coefficients_in_function_ring(self, sparse=True):
+        r"""
+        Return the coefficients of this Drinfeld module as elements
+        of the underlying function ring.
+
+        INPUT:
+
+        - ``sparse`` -- a boolean (default: ``True``); if ``True``,
+          only return the nonzero coefficients; otherwise, return
+          all of them.
+
+        EXAMPLES::
+
+            sage: q = 5
+            sage: Fq = GF(q)
+            sage: A = Fq['T']
+            sage: R = Fq['U']
+            sage: K.<U> = Frac(R)
+            sage: phi = DrinfeldModule(A, [U, 0, U^2, U^3])
+            sage: phi.coefficients_in_function_ring()
+            [T, T^2, T^3]
+            sage: phi.coefficients_in_function_ring(sparse=False)
+            [T, 0, T^2, T^3]
+
+        Compare with the method meth:`coefficients`::
+
+            sage: phi.coefficients()
+            [U, U^2, U^3]
+
+        If the coefficients are not polynomials, an error is raised::
+
+            sage: psi = DrinfeldModule(A, [U, 1/U])
+            sage: psi.coefficients_in_function_ring()
+            Traceback (most recent call last):
+            ...
+            ValueError: coefficients are not polynomials
+        """
+        A = self.function_ring()
+        gs = []
+        for g in self.coefficients(sparse):
+            g = g.backend(force=True)
+            if g.denominator().is_one():
+                gs.append(A(g.numerator().list()))
+            else:
+                raise ValueError("coefficients are not polynomials")
+        return gs
+
+    def class_polynomial(self):
+        r"""
+        Return the class polynomial, that is the Fitting ideal
+        of the class module, of this Drinfeld module.
+
+        We refer to [Tae2012]_ for the definition and basic
+        properties of the class module.
+
+        EXAMPLES:
+
+        We check that the class module of the Carlitz module
+        is trivial::
+
+            sage: q = 5
+            sage: Fq = GF(q)
+            sage: A = Fq['T']
+            sage: K.<T> = Frac(A)
+            sage: C = DrinfeldModule(A, [T, 1]); C
+            Drinfeld module defined by T |--> t + T
+            sage: C.class_polynomial()
+            1
+
+        When the coefficients of the Drinfeld module have small
+        enough degrees, the class module is always trivial::
+
+            sage: gs = [T] + [A.random_element(degree = q^i)
+            ....:             for i in range(1, 5)]
+            sage: phi = DrinfeldModule(A, gs)
+            sage: phi.class_polynomial()
+            1
+
+        Here is an example with a nontrivial class module::
+
+            sage: phi = DrinfeldModule(A, [T, 2*T^14 + 2*T^4])
+            sage: phi.class_polynomial()
+            T + 3
+
+        TESTS:
+
+        The Drinfeld module must have polynomial coefficients::
+
+            sage: phi = DrinfeldModule(A, [T, 1/T])
+            sage: phi.class_polynomial()
+            Traceback (most recent call last):
+            ...
+            ValueError: coefficients are not polynomials
+        """
+        # The algorithm is based on the following remark:
+        # writing phi_T = g_0 + g_1*tau + ... + g_r*tau^r,
+        # if s > deg(g_i/(q^i - 1)) - 1 for all i, then the
+        # class module is equal to
+        #   H := E(Kinfty/A) / < T^(-s), T^(-s-1), ... >
+        # where E(Kinfty/A) is Kinfty/A equipped with the
+        # A-module structure coming from phi.
+
+        A = self.function_ring()
+        Fq = A.base_ring()
+        q = Fq.cardinality()
+        r = self.rank()
+
+        # We compute the bound s
+        gs = self.coefficients_in_function_ring(sparse=False)
+        s = max(gs[i].degree() // (q**i - 1) for i in range(1, r+1))
+        if s == 0:
+            return A.one()
+
+        # We compute the matrix of phi_T acting on the quotient
+        #   M := (Kinfty/A) / < T^(-s), T^(-s-1), ... >
+        # (for the standard structure of A-module!)
+        M = matrix(Fq, s)
+        qk = 1
+        for k in range(r+1):
+            for i in range(s):
+                e = (i+1)*qk
+                for j in range(s):
+                    e -= 1
+                    if e < 0:
+                        break
+                    M[i, j] += gs[k][e]
+            qk *= q
+
+        # We compute the subspace of E(Kinfty/A) (for the twisted
+        # structure of A-module!)
+        #   V = < T^(-s), T^(-s+1), ... >
+        # It is also the phi_T-saturation of T^(-s+1) in M, i.e.
+        # the Fq-vector space generated by the phi_T^i(T^(-s+1))
+        # for i varying in NN.
+        v = vector(Fq, s)
+        v[s-1] = 1
+        vs = [v]
+        for i in range(s-1):
+            v = v*M
+            vs.append(v)
+        V = matrix(vs)
+        V.echelonize()
+
+        # We compute the action of phi_T on H = M/V
+        # as an Fq-linear map (encoded in the matrix N)
+        dim = V.rank()
+        pivots = V.pivots()
+        j = ip = 0
+        for i in range(dim, s):
+            while ip < dim and j == pivots[ip]:
+                j += 1
+            ip += 1
+            V[i,j] = 1
+        N = (V * M * ~V).submatrix(dim, dim)
+
+        # The class module is now H where the action of T
+        # is given by the matrix N
+        # The class polynomial is then the characteristic
+        # polynomial of N
+        return A(N.charpoly())

sage/rings/function_field/drinfeld_modules/drinfeld_module.py

@@ -37,6 +37,7 @@ from sage.misc.lazy_string import _LazyString
 from sage.misc.misc_c import prod
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
+from sage.rings.fraction_field import FractionField_generic
 from sage.rings.polynomial.ore_polynomial_element import OrePolynomial
 from sage.rings.polynomial.polynomial_ring import PolynomialRing_generic
 from sage.structure.parent import Parent
@@ -622,9 +623,17 @@ class DrinfeldModule(Parent, UniqueRepresentation):
             raise ValueError('generator must have positive degree')
 
         # Instantiate the appropriate class:
-        if base_field.is_finite():
+        backend = base_field.backend(force=True)
+        if backend.is_finite():
             from sage.rings.function_field.drinfeld_modules.finite_drinfeld_module import DrinfeldModule_finite
             return DrinfeldModule_finite(gen, category)
+        if isinstance(backend, FractionField_generic):
+            ring = backend.ring()
+            if (isinstance(ring, PolynomialRing_generic)
+            and ring.base_ring() is function_ring_base
+            and base_morphism(T) == ring.gen()):
+                from .charzero_drinfeld_module import DrinfeldModule_rational
+                return DrinfeldModule_rational(gen, category)
         if not category._characteristic:
             from .charzero_drinfeld_module import DrinfeldModule_charzero
             return DrinfeldModule_charzero(gen, category)

sage/rings/function_field/drinfeld_modules/finite_drinfeld_module.py

@@ -572,7 +572,7 @@ class DrinfeldModule_finite(DrinfeldModule):
         Instead, use :meth:`frobenius_charpoly` with the option
         `algorithm='gekeler'`.
 
-        .. WARNING:
+        .. WARNING::
 
             This algorithm only works in the generic case when the
             corresponding linear system is invertible. Notable cases

sage/rings/function_field/drinfeld_modules/homset.py

@@ -18,7 +18,7 @@ AUTHORS:
 #  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/
+#                   https://www.gnu.org/licenses/
 # *****************************************************************************
 
 import operator
@@ -28,7 +28,6 @@ from sage.categories.homset import Homset
 from sage.categories.action import Action
 from sage.misc.latex import latex
 from sage.rings.function_field.drinfeld_modules.morphism import DrinfeldModuleMorphism
-from sage.structure.parent import Parent
 
 
 class DrinfeldModuleMorphismAction(Action):

sage/rings/function_field/drinfeld_modules/morphism.py

@@ -745,7 +745,7 @@ class DrinfeldModuleMorphism(Morphism, UniqueRepresentation,
             sage: f.characteristic_polynomial()
             X^3 + (T + 1)*X^2 + (2*T + 3)*X + 2*T^3 + T + 1
 
-        We verify, on an example, that the caracteristic polynomial
+        We verify, on an example, that the characteristic polynomial
         of a morphism corresponding to `\phi_a` is `(X-a)^r` where `r`
         is the rank::
 
@@ -804,7 +804,7 @@ class DrinfeldModuleMorphism(Morphism, UniqueRepresentation,
             Endomorphism of Drinfeld module defined by T |--> z*t^3 + t^2 + z
               Defn: 0
 
-        We verify, on an example, that the caracteristic polynomial
+        We verify, on an example, that the characteristic polynomial
         of the morphism corresponding to `\phi_a` is `(X-a)^r` where `r`
         is the rank::