Ticket #23471: 23471_over_14825.diff

src/sage/rings/number_field/number_field.py

@@ -1362 +1362 @@
             else:
                 parent, x = embedding.parent(), embedding
             embedding = number_field_morphisms.NumberFieldEmbedding(self, parent, x)
-        self._populate_coercion_lists_(embedding=embedding)
+        self._populate_coercion_lists_(embedding=embedding, convert_method_name='_number_field_')
 
     def _convert_map_from_(self, other):
         r"""

src/sage/rings/number_field/order.py

@@ -1091 +1091 @@
         Quadratic elements have a special optimized type:
 
         """
-        Order.__init__(self, K, is_maximal=is_maximal)
-
         if K.degree() == 2:
             self._element_type = OrderElement_quadratic
             # adding the following attribute makes the comparison of elements
@@ -1102 +1100 @@
             self._element_type = OrderElement_absolute
 
         self._module_rep = module_rep
-        V, from_v, to_v = self._K.vector_space()
+        V, from_v, to_v = K.vector_space()
+        Order.__init__(self, K, is_maximal=is_maximal)
+
         if check:
             if not K.is_absolute():
                 raise ValueError("AbsoluteOrder must be called with an absolute number field.")
@@ -1473 +1473 @@
             sage: loads(dumps(O)) == O
             True
         """
-        Order.__init__(self, K, is_maximal=is_maximal)
         self._absolute_order = absolute_order
         self._module_rep = absolute_order._module_rep
+        Order.__init__(self, K, is_maximal=is_maximal)
 
     def _element_constructor_(self, x):
         """

src/sage/rings/padics/padic_ZZ_pX_CA_element.pyx

@@ -1703 +1703 @@
         """
         R = self.base_ring()
         S = R[var]
-        if self.absprec == 0:
+        if self.is_zero():
             return S([])
         e = self.parent().e()
         L = [Integer(c) for c in self._ntl_rep().list()]

src/sage/rings/padics/padic_ZZ_pX_CR_element.pyx

@@ -2524 +2524 @@
         """
         R = self.base_ring()
         S = R[var]
-        if self.relprec == 0:
+        if self.is_zero():
             return S([])
         prec = self.relprec + self.ordp
         e = self.parent().e()

src/sage/rings/padics/padic_ZZ_pX_FM_element.pyx

@@ -1152 +1152 @@
         """
         R = self.base_ring()
         S = R[var]
+        if self.is_zero():
+            return S([])
         return S([Integer(c) for c in self._ntl_rep().list()])
 
     cdef ZZ_p_c _const_term(self):

src/sage/rings/padics/padic_extension_generic.py

@@ -22 +22 @@
 
 from .padic_generic import pAdicGeneric
 from .padic_base_generic import pAdicBaseGeneric
+from sage.rings.number_field.number_field_base import NumberField
+from sage.rings.number_field.order import Order
+from sage.rings.rational_field import QQ
 from sage.structure.richcmp import op_EQ
 from functools import reduce
-
+from sage.categories.morphism import Morphism
+from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
+from sage.categories.integral_domains import IntegralDomains
+from sage.categories.fields import Fields
+from sage.categories.homset import Hom
 
 class pAdicExtensionGeneric(pAdicGeneric):
     def __init__(self, poly, prec, print_mode, names, element_class):
@@ -62 +69 @@
 
     def _coerce_map_from_(self, R):
         """
-        Returns True if there is a coercion map from R to self.
+        Finds coercion maps from R to this ring.
 
         EXAMPLES::
 
@@ -85 +92 @@
                 from sage.rings.padics.qadic_flint_FP import pAdicCoercion_FP_frac_field as coerce_map
             return coerce_map(R, self)
 
+    def _convert_map_from_(self, R):
+        """
+        Finds conversion maps from R to this ring.
+
+        Currently, a conversion exists if the defining polynomial is the same.
+
+        EXAMPLES::
+
+            sage: R.<a> = Zq(125)
+            sage: S = R.change(type='capped-abs', prec=40, print_mode='terse', print_pos=False)
+            sage: S(a - 15)
+            -15 + a + O(5^20)
+
+        We get conversions from the exact field::
+
+            sage: K = R.exact_field(); K
+            Number Field in a with defining polynomial x^3 + 3*x + 3
+            sage: R(K.gen())
+            a + O(5^20)
+
+        and its maximal order::
+
+            sage: OK = K.maximal_order()
+            sage: R(OK.gen(1))
+            a + O(5^20)
+        """
+        cat = None
+        if self._implementation == 'NTL' and R == QQ:
+            # Want to use DefaultConvertMap
+            return None
+        if isinstance(R, pAdicExtensionGeneric) and R.defining_polynomial(exact=True) == self.defining_polynomial(exact=True):
+            if R.is_field() and not self.is_field():
+                cat = SetsWithPartialMaps()
+            else:
+                cat = R.category()
+        elif isinstance(R, Order) and R.number_field().defining_polynomial() == self.defining_polynomial():
+            cat = IntegralDomains()
+        elif isinstance(R, NumberField) and R.defining_polynomial() == self.defining_polynomial():
+            if self.is_field():
+                cat = Fields()
+            else:
+                cat = SetsWithPartialMaps()
+        if cat is not None:
+            H = Hom(R, self, cat)
+            return H.__make_element_class__(DefPolyConversion)(H)
+
     def __eq__(self, other):
         """
         Return ``True`` if ``self == other`` and ``False`` otherwise.
@@ -448 +501 @@
     #def zeta_order(self):
     #    raise NotImplementedError
 
+class DefPolyConversion(Morphism):
+    """
+    Conversion map between p-adic rings/fields with the same defining polynomial.
+
+    INPUT:
+
+    - ``R`` -- a p-adic extension ring or field.
+    - ``S`` -- a p-adic extension ring or field with the same defining polynomial.
+
+    EXAMPLES::
+
+        sage: R.<a> = Zq(125, print_mode='terse')
+        sage: S = R.change(prec = 15, type='floating-point')
+        sage: a - 1
+        95367431640624 + a + O(5^20)
+        sage: S(a - 1)
+        30517578124 + a + O(5^15)
+
+    ::
+
+        sage: R.<a> = Zq(125, print_mode='terse')
+        sage: S = R.change(prec = 15, type='floating-point')
+        sage: f = S.convert_map_from(R)
+        sage: TestSuite(f).run()
+    """
+    def _call_(self, x):
+        """
+        Use the polynomial associated to the element to do the conversion.
+
+        EXAMPLES::
+
+            sage: S.<x> = ZZ[]
+            sage: W.<w> = Zp(3).extension(x^4 + 9*x^2 + 3*x - 3)
+            sage: z = W.random_element()
+            sage: repr(W.change(print_mode='digits')(z))
+            '...20112102111011011200001212210222202220100111100200011222122121202100210120010120'
+        """
+        S = self.codomain()
+        Sbase = S.base_ring()
+        L = x.polynomial().list()
+        if L and not (len(L) == 1 and L[0].is_zero()):
+            return S([Sbase(c) for c in L])
+        # Inexact zeros need to be handled separately
+        elif isinstance(x.parent(), pAdicExtensionGeneric):
+            return S(0, x.precision_absolute())
+        else:
+            return S(0)
+
+    def _call_with_args(self, x, args=(), kwds={}):
+        """
+        Use the polynomial associated to the element to do the conversion,
+        passing arguments along to the codomain.
+
+        EXAMPLES::
+
+            sage: S.<x> = ZZ[]
+            sage: W.<w> = Zp(3).extension(x^4 + 9*x^2 + 3*x - 3)
+            sage: z = W.random_element()
+            sage: repr(W.change(print_mode='digits')(z, absprec=8))
+            '...20010120'
+        """
+        S = self.codomain()
+        Sbase = S.base_ring()
+        L = x.polynomial().list()
+        if L and not (len(L) == 1 and L[0].is_zero()):
+            return S([Sbase(c) for c in L], *args, **kwds)
+        # Inexact zeros need to be handled separately
+        elif isinstance(x.parent(), pAdicExtensionGeneric):
+            if args:
+                if 'absprec' in kwds:
+                    raise TypeError("_call_with_args() got multiple values for keyword argument 'absprec'")
+                absprec = args[0]
+                args = args[1:]
+            else:
+                absprec = kwds.pop('absprec',x.precision_absolute())
+            absprec = min(absprec, x.precision_absolute())
+            return S(0, absprec, *args, **kwds)
+        else:
+            return S(0, *args, **kwds)

src/sage/rings/padics/padic_generic_element.pyx

@@ -1588 +1588 @@
             p = self.parent().prime()
             return Rational(p**self.valuation() * self.unit_part().lift())
 
+    def _number_field_(self, K):
+        r"""
+        Return an element of K approximating this p-adic number.
+
+        INPUT:
+
+        - ``K`` -- a number field
+
+        EXAMPLES::
+
+            sage: R.<a> = Zq(125)
+            sage: K = R.exact_field()
+            sage: a._number_field_(K)
+            a
+        """
+        Kbase = K.base_ring()
+        if K.defining_polynomial() != self.parent().defining_polynomial(exact=True):
+            # Might convert to K's base ring.
+            return Kbase(self)
+        L = [Kbase(c) for c in self.polynomial().list()]
+        if len(L) < K.degree():
+            L += [Kbase(0)] * (K.degree() - len(L))
+        return K(L)
+
     def _log_generic(self, aprec, mina=0):
         r"""
         Return ``\log(self)`` for ``self`` equal to 1 in the residue field
@@ -2043 +2067 @@
 
             sage: R = ZpFM(2, prec=5)
             sage: R(180).log(p_branch=0) == R(30).log(p_branch=0) + R(6).log(p_branch=0)
-            False            
+            False
 
         Check that log is the inverse of exp::
 
@@ -2141 +2165 @@
         - Julian Rueth (2013-02-14): Added doctests, some changes for
           capped-absolute implementations.
 
-        - Xavier Caruso (2017-06): Added binary splitting type algorithms 
+        - Xavier Caruso (2017-06): Added binary splitting type algorithms
           over Qp
 
         """