Merge branch 'drinfeld-module' of github:kryzar/sage into drinfeld-module

Author: xcaruso

src/sage/categories/drinfeld_modules.py

@@ -18,6 +18,7 @@
 #                   http://www.gnu.org/licenses/
 # ******************************************************************************
 
+from sage.categories.objects import Objects
 from sage.categories.category_types import Category_over_base_ring
 from sage.categories.homsets import Homsets
 from sage.misc.functional import log
@@ -472,7 +473,7 @@ def object(self, gen):
         INPUT:
 
         - ``gen`` -- the generator of the Drinfeld module, given as an Ore
-        polynomial or a list of coefficients
+          polynomial or a list of coefficients
 
         EXAMPLES::
 
@@ -565,9 +566,9 @@ def super_categories(self):
             sage: phi = DrinfeldModule(A, [p_root, 0, 0, 1])
             sage: C = phi.category()
             sage: C.super_categories()
-            []
+            [Category of objects]
         """
-        return []
+        return [Objects()]
 
     class ParentMethods:
 

src/sage/rings/function_field/drinfeld_modules/action.py

@@ -150,7 +150,7 @@ def _latex_(self):
             sage: phi = DrinfeldModule(A, [z, 0, 0, 1])
             sage: action = phi.action()
             sage: latex(action)
-            \text{Action{ }on{ }}\Bold{F}_{11^{2}}\text{{ }induced{ }by{ }}\text{Drinfeld{ }module{ }defined{ }by{ }} T \mapsto t^{3} + z\text{{ }over{ }base{ }}\Bold{F}_{11^{2}}
+            \text{Action{ }on{ }}\Bold{F}_{11^{2}}\text{{ }induced{ }by{ }}\phi: T \mapsto t^{3} + z
         """
         return f'\\text{{Action{{ }}on{{ }}}}' \
                f'{latex(self._base)}\\text{{{{ }}' \

src/sage/rings/function_field/drinfeld_modules/drinfeld_module.py

@@ -27,11 +27,14 @@
 from sage.categories.drinfeld_modules import DrinfeldModules
 from sage.categories.homset import Hom
 from sage.misc.latex import latex
+from sage.misc.latex import latex_variable_name
+from sage.misc.lazy_string import _LazyString
 from sage.rings.integer import Integer
 from sage.rings.polynomial.ore_polynomial_element import OrePolynomial
 from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
 from sage.rings.ring_extension import RingExtension_generic
 from sage.structure.parent import Parent
+from sage.structure.sage_object import SageObject
 from sage.structure.sequence import Sequence
 from sage.structure.unique_representation import UniqueRepresentation
 
@@ -172,20 +175,13 @@ class DrinfeldModule(Parent, UniqueRepresentation):
         sage: phi(1)  # phi_1
         1
 
-    One can give a LaTeX name to be used for LaTeX representation::
-
-        sage: sigma = DrinfeldModule(A, [z, 1, 1], latexname='\sigma')
-        ...
-        sage: latex(sigma)
-        \sigma
-
     .. RUBRIC:: The category of Drinfeld modules
 
     Drinfeld modules have their own category (see class
     :class:`sage.categories.drinfeld_modules.DrinfeldModules`)::
 
         sage: phi.category()
-        Category of Drinfeld modules defined over Finite Field in z of size 3^12 over its base
+        Category of Drinfeld modules over Finite Field in z of size 3^12 over its base
         sage: phi.category() is psi.category()
         False
         sage: phi.category() is rho.category()
@@ -271,10 +267,10 @@ class DrinfeldModule(Parent, UniqueRepresentation):
         sage: phi.j_invariant()  # j-invariant
         1
 
-     A Drinfeld `\mathbb{F}_q[T]`-module can be seen as an Ore
-     polynomial with positive degree and constant coefficient
-     `\gamma(T)`, where `\gamma` is the base morphism. This analogy is
-     the motivation for the following methods::
+    A Drinfeld `\mathbb{F}_q[T]`-module can be seen as an Ore polynomial
+    with positive degree and constant coefficient `\gamma(T)`, where
+    `\gamma` is the base morphism. This analogy is the motivation for
+    the following methods::
 
         sage: phi.coefficients()
         [z, 1, 1]
@@ -316,20 +312,13 @@ class DrinfeldModule(Parent, UniqueRepresentation):
         sage: identity_morphism = hom(1)
         sage: zero_morphism = hom(0)
         sage: frobenius_endomorphism
-        Drinfeld Module morphism:
-          From (gen): t^2 + t + z
-          To (gen):   t^2 + t + z
-          Defn:       t^6
+        Endomorphism of Drinfeld module defined by T |--> t^2 + t + z
+          Defn: t^6
         sage: identity_morphism
-        Drinfeld Module morphism:
-          From (gen): t^2 + t + z
-          To (gen):   t^2 + t + z
-          Defn:       1
+        Identity morphism of Drinfeld module defined by T |--> t^2 + t + z
         sage: zero_morphism
-        Drinfeld Module morphism:
-          From (gen): t^2 + t + z
-          To (gen):   t^2 + t + z
-          Defn:       0
+        Endomorphism of Drinfeld module defined by T |--> t^2 + t + z
+          Defn: 0
 
     The underlying Ore polynomial is retrieved with the method
     :meth:`ore_polynomial`::
@@ -512,7 +501,7 @@ class DrinfeldModule(Parent, UniqueRepresentation):
     """
 
     @staticmethod
-    def __classcall_private__(cls, function_ring, gen, name='t', latexname=None):
+    def __classcall_private__(cls, function_ring, gen, name='t'):
         """
         Check input validity and return a ``DrinfeldModule`` or
         ``FiniteDrinfeldModule`` object accordingly.
@@ -528,9 +517,6 @@ def __classcall_private__(cls, function_ring, gen, name='t', latexname=None):
         - ``name`` (default: ``'t'``) -- the name of the Ore polynomial
           ring gen
 
-        - ``latexname`` (default: ``None``) -- the LaTeX name of the Drinfeld
-          module
-
         OUTPUT:
 
         A DrinfeldModule or FiniteDrinfeldModule.
@@ -591,10 +577,6 @@ def __classcall_private__(cls, function_ring, gen, name='t', latexname=None):
                 base_field_noext.has_coerce_map_from(function_ring.base_ring())):
             raise ValueError('function ring base must coerce into base field')
 
-        # Check LaTeX name
-        if latexname is not None and type(latexname) is not str:
-            raise ValueError('LaTeX name should be a string')
-
         # Build the category
         T = function_ring.gen()
         if isinstance(base_field_noext, RingExtension_generic):
@@ -607,6 +589,11 @@ def __classcall_private__(cls, function_ring, gen, name='t', latexname=None):
             base_morphism = Hom(function_ring, base_field_noext)(gen[0])
             base_field = base_field_noext.over(base_morphism)
 
+        # This test is also done in the category. We put it here also
+        # to have a friendlier error message
+        if not base_field.is_field():
+            raise ValueError('generator coefficients must live in a field')
+
         category = DrinfeldModules(base_field, name=name)
 
         # Check gen as Ore polynomial
@@ -618,10 +605,10 @@ def __classcall_private__(cls, function_ring, gen, name='t', latexname=None):
         # Instantiate the appropriate class
         if base_field.is_finite():
             from sage.rings.function_field.drinfeld_modules.finite_drinfeld_module import FiniteDrinfeldModule
-            return FiniteDrinfeldModule(gen, category, latexname)
-        return cls.__classcall__(cls, gen, category, latexname)
+            return FiniteDrinfeldModule(gen, category)
+        return cls.__classcall__(cls, gen, category)
 
-    def __init__(self, gen, category, latexname=None):
+    def __init__(self, gen, category):
         """
         Initialize ``self``.
 
@@ -639,9 +626,6 @@ def __init__(self, gen, category, latexname=None):
         - ``name`` (default: ``'t'``) -- the name of the Ore polynomial
           ring gen
 
-        - ``latexname`` (default: ``None``) -- the LaTeX name of the Drinfeld
-          module
-
         TESTS::
 
             sage: Fq = GF(25)
@@ -661,13 +645,14 @@ def __init__(self, gen, category, latexname=None):
             True
             sage: phi._morphism == Hom(A, ore_polring)(phi._gen)
             True
-            sage: phi._latexname is None
-            True
+
+        ::
+
+            sage: TestSuite(phi).run()
         """
         self._base = category.base()
         self._function_ring = category.function_ring()
         self._gen = gen
-        self._latexname = latexname
         self._morphism = category._function_ring.hom([gen])
         self._ore_polring = gen.parent()
         self._Fq = self._function_ring.base_ring()  # Must be last
@@ -777,8 +762,8 @@ def _latex_(self):
         r"""
         Return a LaTeX representation of the Drinfeld module.
 
-        If a LaTeX name was given at initialization, we use it.
-        Otherwise, we create a representation.
+        If a representation name is given with meth:`rename`, it is
+        taken into account for LaTeX representation.
 
         EXAMPLES::
 
@@ -788,29 +773,20 @@ def _latex_(self):
             sage: p_root = 2*z12^11 + 2*z12^10 + z12^9 + 3*z12^8 + z12^7 + 2*z12^5 + 2*z12^4 + 3*z12^3 + z12^2 + 2*z12
             sage: phi = DrinfeldModule(A, [p_root, z12^3, z12^5])
             sage: latex(phi)
-            \text{Drinfeld{ }module{ }defined{ }by{ }} T \mapsto z_{12}^{5} t^{2} + z_{12}^{3} t + 2 z_{12}^{11} + 2 z_{12}^{10} + z_{12}^{9} + 3 z_{12}^{8} + z_{12}^{7} + 2 z_{12}^{5} + 2 z_{12}^{4} + 3 z_{12}^{3} + z_{12}^{2} + 2 z_{12}\text{{ }over{ }base{ }}\Bold{F}_{5^{12}}
+            \phi: T \mapsto z_{12}^{5} t^{2} + z_{12}^{3} t + 2 z_{12}^{11} + 2 z_{12}^{10} + z_{12}^{9} + 3 z_{12}^{8} + z_{12}^{7} + 2 z_{12}^{5} + 2 z_{12}^{4} + 3 z_{12}^{3} + z_{12}^{2} + 2 z_{12}
 
         ::
 
-            sage: psi = DrinfeldModule(A, [p_root, z12^3, z12^5], latexname='\psi')
-            ...
-            sage: latex(psi)
-            \psi
-
-        ::
-
-            sage: psi = DrinfeldModule(A, [p_root, z12^3, z12^5], latexname=1729)
-            Traceback (most recent call last):
-            ...
-            ValueError: LaTeX name should be a string
+            sage: phi.rename('phi')
+            sage: latex(phi)
+            \phi
+            sage: phi.reset_name()
         """
-        if self._latexname is not None:
-            return self._latexname
+        if hasattr(self, '__custom_name'):
+            return latex_variable_name(getattr(self, '__custom_name'))
         else:
-            return f'\\text{{Drinfeld{{ }}module{{ }}defined{{ }}by{{ }}}} ' \
-                   f'{latex(self._function_ring.gen())} '\
-                   f'\\mapsto {latex(self._gen)}' \
-                   f'\\text{{{{ }}over{{ }}base{{ }}}}{latex(self._base)}'
+            return f'\\phi: {latex(self._function_ring.gen())} \\mapsto ' \
+                   f'{latex(self._gen)}'
 
     def _repr_(self):
         r"""
@@ -829,6 +805,49 @@ def _repr_(self):
         return f'Drinfeld module defined by {self._function_ring.gen()} ' \
                f'|--> {self._gen}'
 
+    def _test_category(self, **options):
+        """
+        Run generic tests on the method :meth:`.category`.
+
+        EXAMPLES::
+
+            sage: Fq = GF(25)
+            sage: A.<T> = Fq[]
+            sage: K.<z12> = Fq.extension(6)
+            sage: p_root = 2*z12^11 + 2*z12^10 + z12^9 + 3*z12^8 + z12^7 + 2*z12^5 + 2*z12^4 + 3*z12^3 + z12^2 + 2*z12
+            sage: phi = DrinfeldModule(A, [p_root, z12^3, z12^5])
+            sage: phi._test_category()
+
+        .. NOTE::
+
+            We reimplemented this method because Drinfeld modules are
+            parents, and
+            meth:`sage.structure.parent.Parent._test_category` requires
+            parents' categories to be subcategories of ``Sets()``.
+        """
+        tester = self._tester(**options)
+        SageObject._test_category(self, tester=tester)
+        category = self.category()
+        # Tests that self inherits methods from the categories
+        tester.assertTrue(isinstance(self, category.parent_class),
+                _LazyString("category of %s improperly initialized", (self,), {}))
+
+    def __hash__(self):
+        r"""
+        Return a hash of ``self``.
+
+        EXAMPLES::
+
+            sage: Fq = GF(25)
+            sage: A.<T> = Fq[]
+            sage: K.<z12> = Fq.extension(6)
+            sage: p_root = 2*z12^11 + 2*z12^10 + z12^9 + 3*z12^8 + z12^7 + 2*z12^5 + 2*z12^4 + 3*z12^3 + z12^2 + 2*z12
+            sage: phi = DrinfeldModule(A, [p_root, z12^3, z12^5])
+            sage: hash(phi)  # random
+            -6894299335185957188
+        """
+        return hash((self.base(), self._gen))
+
     def action(self):
         r"""
         Return the action object

src/sage/rings/function_field/drinfeld_modules/finite_drinfeld_module.py

@@ -77,10 +77,8 @@ class FiniteDrinfeldModule(DrinfeldModule):
 
         sage: frobenius_endomorphism = phi.frobenius_endomorphism()
         sage: frobenius_endomorphism
-        Drinfeld Module morphism:
-          From (gen): 5*t^2 + z6
-          To (gen):   5*t^2 + z6
-          Defn:       t^2
+        Endomorphism of Drinfeld module defined by T |--> 5*t^2 + z6
+          Defn: t^2
 
     Its characteristic polynomial can be computed::
 
@@ -118,7 +116,7 @@ class FiniteDrinfeldModule(DrinfeldModule):
         True
     """
 
-    def __init__(self, gen, category, latexname=None):
+    def __init__(self, gen, category):
         """
         Initialize `self`.
 
@@ -136,9 +134,6 @@ def __init__(self, gen, category, latexname=None):
         - ``name`` (default: `'t'`) -- the name of the Ore polynomial
           ring gen
 
-        - ``latexname`` (default: ``None``) -- the LaTeX name of the Drinfeld
-          module
-
         TESTS::
 
             sage: Fq = GF(25)
@@ -154,7 +149,7 @@ def __init__(self, gen, category, latexname=None):
         # NOTE: There used to be no __init__ here (which was fine). I
         # added one to ensure that FiniteDrinfeldModule would always
         # have _frobenius_norm and _frobenius_trace attributes.
-        super().__init__(gen, category, latexname)
+        super().__init__(gen, category)
         self._frobenius_norm = None
         self._frobenius_trace = None
 
@@ -174,10 +169,8 @@ def frobenius_endomorphism(self):
             sage: K.<z6> = Fq.extension(2)
             sage: phi = DrinfeldModule(A, [1, 0, z6])
             sage: phi.frobenius_endomorphism()
-            Drinfeld Module morphism:
-              From (gen): z6*t^2 + 1
-              To (gen):   z6*t^2 + 1
-              Defn:       t^2
+            Endomorphism of Drinfeld module defined by T |--> z6*t^2 + 1
+              Defn: t^2
 
        TESTS::