P/35230/refactor function field

src/doc/en/reference/function_fields/index.rst

@@ -18,6 +18,7 @@ algebraic closure of `\QQ`.
    sage/rings/function_field/divisor
    sage/rings/function_field/differential
    sage/rings/function_field/valuation_ring
+   sage/rings/function_field/derivations
    sage/rings/function_field/maps
    sage/rings/function_field/extensions
    sage/rings/function_field/constructor

src/sage/categories/function_fields.py

@@ -52,14 +52,14 @@ def _call_(self, x):
         EXAMPLES::
 
             sage: C = FunctionFields()
-            sage: K.<x>=FunctionField(QQ)
+            sage: K.<x> = FunctionField(QQ)
             sage: C(K)
             Rational function field in x over Rational Field
             sage: Ky.<y> = K[]
-            sage: L = K.extension(y^2-x)
-            sage: C(L)
+            sage: L = K.extension(y^2 - x)                                              # optional - sage.libs.singular
+            sage: C(L)                                                                  # optional - sage.libs.singular
             Function field in y defined by y^2 - x
-            sage: C(L.equation_order())
+            sage: C(L.equation_order())                                                 # optional - sage.libs.singular
             Function field in y defined by y^2 - x
         """
         try:

src/sage/rings/derivation.py

@@ -196,7 +196,8 @@
 from sage.rings.polynomial.polynomial_quotient_ring import PolynomialQuotientRing_generic
 from sage.rings.finite_rings.integer_mod_ring import IntegerModRing_generic
 from sage.rings.padics.padic_generic import pAdicGeneric
-from sage.rings.function_field.function_field import FunctionField, RationalFunctionField
+from sage.rings.function_field.function_field import FunctionField
+from sage.rings.function_field.function_field_rational import RationalFunctionField
 from sage.categories.number_fields import NumberFields
 from sage.categories.finite_fields import FiniteFields
 from sage.categories.modules import Modules
@@ -391,13 +392,13 @@ def __init__(self, domain, codomain, twist=None):
             constants, sharp = self._base_derivation._constants
             self._constants = (constants, False)  # can we do better?
         elif isinstance(domain, RationalFunctionField):
-            from sage.rings.function_field.maps import FunctionFieldDerivation_rational
+            from sage.rings.function_field.derivations_rational import FunctionFieldDerivation_rational
             self.Element = FunctionFieldDerivation_rational
             self._gens = self._basis = [ None ]
             self._dual_basis = [ domain.gen() ]
         elif isinstance(domain, FunctionField):
             if domain.is_separable():
-                from sage.rings.function_field.maps import FunctionFieldDerivation_separable
+                from sage.rings.function_field.derivations_polymod import FunctionFieldDerivation_separable
                 self._base_derivation = RingDerivationModule(domain.base_ring(), defining_morphism)
                 self.Element = FunctionFieldDerivation_separable
                 try:
@@ -410,7 +411,7 @@ def __init__(self, domain, codomain, twist=None):
                 except NotImplementedError:
                     pass
             else:
-                from sage.rings.function_field.maps import FunctionFieldDerivation_inseparable
+                from sage.rings.function_field.derivations_polymod import FunctionFieldDerivation_inseparable
                 M, f, self._t = domain.separable_model()
                 self._base_derivation = RingDerivationModule(M, defining_morphism * f)
                 self._d = self._base_derivation(None)

src/sage/rings/fraction_field.py

@@ -1056,7 +1056,7 @@ def _coerce_map_from_(self, R):
             1/t
 
         """
-        from sage.rings.function_field.function_field import RationalFunctionField
+        from sage.rings.function_field.function_field_rational import RationalFunctionField
         if isinstance(R, RationalFunctionField) and self.variable_name() == R.variable_name() and self.base_ring() is R.constant_base_field():
             from sage.categories.homset import Hom
             parent = Hom(R, self)

src/sage/rings/function_field/constructor.py

@@ -54,10 +54,10 @@ class FunctionFieldFactory(UniqueFactory):
 
         sage: K.<x> = FunctionField(QQ); K
         Rational function field in x over Rational Field
-        sage: L.<y> = FunctionField(GF(7)); L
+        sage: L.<y> = FunctionField(GF(7)); L                                           # optional - sage.libs.pari
         Rational function field in y over Finite Field of size 7
-        sage: R.<z> = L[]
-        sage: M.<z> = L.extension(z^7-z-y); M
+        sage: R.<z> = L[]                                                               # optional - sage.libs.pari
+        sage: M.<z> = L.extension(z^7 - z - y); M                                       # optional - sage.libs.pari
         Function field in z defined by z^7 + 6*z + 6*y
 
     TESTS::
@@ -66,8 +66,8 @@ class FunctionFieldFactory(UniqueFactory):
         sage: L.<x> = FunctionField(QQ)
         sage: K is L
         True
-        sage: M.<x> = FunctionField(GF(7))
-        sage: K is M
+        sage: M.<x> = FunctionField(GF(7))                                              # optional - sage.libs.pari
+        sage: K is M                                                                    # optional - sage.libs.pari
         False
         sage: N.<y> = FunctionField(QQ)
         sage: K is N
@@ -99,13 +99,13 @@ def create_object(self, version, key,**extra_args):
             True
         """
         if key[0].is_finite():
-            from .function_field import RationalFunctionField_global
+            from .function_field_rational import RationalFunctionField_global
             return RationalFunctionField_global(key[0], names=key[1])
         elif key[0].characteristic() == 0:
-            from .function_field import RationalFunctionField_char_zero
+            from .function_field_rational import RationalFunctionField_char_zero
             return RationalFunctionField_char_zero(key[0], names=key[1])
         else:
-            from .function_field import RationalFunctionField
+            from .function_field_rational import RationalFunctionField
             return RationalFunctionField(key[0], names=key[1])
 
 FunctionField=FunctionFieldFactory("sage.rings.function_field.constructor.FunctionField")
@@ -133,9 +133,9 @@ class FunctionFieldExtensionFactory(UniqueFactory):
         sage: y2 = y*1
         sage: y2 is y
         False
-        sage: L.<w>=K.extension(x - y^2)
-        sage: M.<w>=K.extension(x - y2^2)
-        sage: L is M
+        sage: L.<w> = K.extension(x - y^2)                                              # optional - sage.libs.singular
+        sage: M.<w> = K.extension(x - y2^2)                                             # optional - sage.libs.singular
+        sage: L is M                                                                    # optional - sage.libs.singular
         True
     """
     def create_key(self,polynomial,names):
@@ -147,20 +147,20 @@ def create_key(self,polynomial,names):
 
             sage: K.<x> = FunctionField(QQ)
             sage: R.<y> = K[]
-            sage: L.<w> = K.extension(x - y^2) # indirect doctest
+            sage: L.<w> = K.extension(x - y^2) # indirect doctest                       # optional - sage.libs.singular
 
         TESTS:
 
         Verify that :trac:`16530` has been resolved::
 
             sage: K.<x> = FunctionField(QQ)
             sage: R.<y> = K[]
-            sage: L.<y> = K.extension(y^2 - x)
-            sage: R.<z> = L[]
-            sage: M.<z> = L.extension(z - 1)
+            sage: L.<y> = K.extension(y^2 - x)                                          # optional - sage.libs.singular
+            sage: R.<z> = L[]                                                           # optional - sage.libs.singular
+            sage: M.<z> = L.extension(z - 1)                                            # optional - sage.libs.singular
             sage: R.<z> = K[]
-            sage: N.<z> = K.extension(z - 1)
-            sage: M is N
+            sage: N.<z> = K.extension(z - 1)                                            # optional - sage.libs.singular
+            sage: M is N                                                                # optional - sage.libs.singular
             False
 
         """
@@ -179,32 +179,33 @@ def create_object(self,version,key,**extra_args):
 
             sage: K.<x> = FunctionField(QQ)
             sage: R.<y> = K[]
-            sage: L.<w> = K.extension(x - y^2) # indirect doctest
-            sage: y2 = y*1
-            sage: M.<w> = K.extension(x - y2^2) # indirect doctest
-            sage: L is M
+            sage: L.<w> = K.extension(x - y^2) # indirect doctest                       # optional - sage.libs.singular
+            sage: y2 = y*1                                                              # optional - sage.libs.singular
+            sage: M.<w> = K.extension(x - y2^2) # indirect doctest                      # optional - sage.libs.singular
+            sage: L is M                                                                # optional - sage.libs.singular
             True
         """
-        from . import function_field
+        from . import function_field_polymod, function_field_rational
+
         f = key[0]
         names = key[1]
         base_field = f.base_ring()
-        if isinstance(base_field, function_field.RationalFunctionField):
+        if isinstance(base_field, function_field_rational.RationalFunctionField):
             k = base_field.constant_field()
             if k.is_finite(): # then we are in positive characteristic
                 # irreducible and separable
                 if f.is_irreducible() and not all(e % k.characteristic() == 0 for e in f.exponents()):
                     # monic and integral
                     if f.is_monic() and all(e in base_field.maximal_order() for e in f.coefficients()):
-                        return function_field.FunctionField_global_integral(f, names)
+                        return function_field_polymod.FunctionField_global_integral(f, names)
                     else:
-                        return function_field.FunctionField_global(f, names)
+                        return function_field_polymod.FunctionField_global(f, names)
             elif k.characteristic() == 0:
                 if f.is_irreducible() and f.is_monic() and all(e in base_field.maximal_order() for e in f.coefficients()):
-                    return function_field.FunctionField_char_zero_integral(f, names)
+                    return function_field_polymod.FunctionField_char_zero_integral(f, names)
                 else:
-                    return function_field.FunctionField_char_zero(f, names)
-        return function_field.FunctionField_polymod(f, names)
+                    return function_field_polymod.FunctionField_char_zero(f, names)
+        return function_field_polymod.FunctionField_polymod(f, names)
 
-FunctionFieldExtension=FunctionFieldExtensionFactory(
+FunctionFieldExtension = FunctionFieldExtensionFactory(
     "sage.rings.function_field.constructor.FunctionFieldExtension")

src/sage/rings/function_field/derivations.py

@@ -0,0 +1,88 @@
+r"""
+Derivations of function fields
+
+For global function fields, which have positive characteristics, the higher
+derivation is available::
+
+    sage: K.<x> = FunctionField(GF(2)); _.<Y> = K[]                                                 # optional - sage.libs.pari
+    sage: L.<y> = K.extension(Y^3 + x + x^3*Y)                                                      # optional - sage.libs.pari
+    sage: h = L.higher_derivation()                                                                 # optional - sage.libs.pari
+    sage: h(y^2, 2)                                                                                 # optional - sage.libs.pari
+    ((x^7 + 1)/x^2)*y^2 + x^3*y
+
+AUTHORS:
+
+- William Stein (2010): initial version
+
+- Julian Rüth (2011-09-14, 2014-06-23, 2017-08-21): refactored class hierarchy; added
+  derivation classes; morphisms to/from fraction fields
+
+- Kwankyu Lee (2017-04-30): added higher derivations and completions
+
+"""
+
+from sage.rings.derivation import RingDerivationWithoutTwist
+
+
+class FunctionFieldDerivation(RingDerivationWithoutTwist):
+    r"""
+    Base class for derivations on function fields.
+
+    A derivation on `R` is a map `R \to R` with
+    `D(\alpha+\beta)=D(\alpha)+D(\beta)` and `D(\alpha\beta)=\beta
+    D(\alpha)+\alpha D(\beta)` for all `\alpha,\beta\in R`.
+
+    EXAMPLES::
+
+        sage: K.<x> = FunctionField(QQ)
+        sage: d = K.derivation()
+        sage: d
+        d/dx
+    """
+    def __init__(self, parent):
+        r"""
+        Initialize a derivation.
+
+        INPUT:
+
+        - ``parent`` -- the differential module in which this
+          derivation lives
+
+        EXAMPLES::
+
+            sage: K.<x> = FunctionField(QQ)
+            sage: d = K.derivation()
+            sage: TestSuite(d).run()
+        """
+        RingDerivationWithoutTwist.__init__(self, parent)
+        self.__field = parent.domain()
+
+    def is_injective(self) -> bool:
+        r"""
+        Return ``False`` since a derivation is never injective.
+
+        EXAMPLES::
+
+            sage: K.<x> = FunctionField(QQ)
+            sage: d = K.derivation()
+            sage: d.is_injective()
+            False
+        """
+        return False
+
+    def _rmul_(self, factor):
+        """
+        Return the product of this derivation by the scalar ``factor``.
+
+        EXAMPLES::
+
+            sage: K.<x> = FunctionField(QQ)
+            sage: d = K.derivation()
+            sage: d
+            d/dx
+            sage: x * d
+            x*d/dx
+        """
+        return self._lmul_(factor)
+
+