Ticket #14825: 14825_over_20310.diff

File 14825_over_20310.diff, 95.4 KB (added by roed, 2 years ago)

Diff against 20310

  • src/sage/libs/linkages/padics/API.pxi

    diff --git a/src/sage/libs/linkages/padics/API.pxi b/src/sage/libs/linkages/padics/API.pxi
    index 890a5291de..4219734ea6 100644
    a b file gives the function signatures. 
    4141- :meth:`cunpickle` -- reconstruction from the output of :meth:`cpickle`
    4242- :meth:`chash` -- hashing
    4343- :meth:`clist` -- a list of digits in the series expansion
     44- :meth:`ccoefficients` -- a list of coefficients as elements of the base ring
    4445- :meth:`cteichmuller` -- Teichmuller lifting
    4546- :meth:`cconv` -- conversion from other types in Sage
    4647- :meth:`cconv_mpz_t` -- conversion from mpz_t, separated for speed and
    cdef clist(celement a, long prec, bint pos, PowComputer_class prime_pow): 
    486487# It could be [] for some other linkages.
    487488_list_zero = Integer(0)
    488489
     490cdef list ccoefficients(celement x, long valshift, PowComputer_class prime_pow):
     491    """
     492    Return a list of coefficients, as elements that can be converted into the base ring.
     493
     494    INPUT:
     495
     496    - ``x`` -- a ``celement`` giving the underlying `p`-adic element, or possibly its unit part.
     497    - ``valshift`` -- a long giving the power of the uniformizer to shift `x` by.
     498    - ``prec`` -- a long, the (relative) precision desired, used in rational reconstruction
     499    - ``prime_pow`` -- the Powcomputer of the ring
     500    """
     501    pass
     502
    489503cdef int cteichmuller(celement out, celement value, long prec, PowComputer_class prime_pow) except -1:
    490504    """
    491505    Teichmuller lifting.
    cdef inline int cconv_mpq_t_out(mpq_t out, celement x, long valshift, long prec, 
    585599                 uses rational reconstruction but may change in the
    586600                 future to use a more naive method.
    587601    - ``x`` -- an ``celement`` giving the underlying `p`-adic element.
    588     - ``valshift`` -- a long giving the power of `p` to shift `x` by.
     602    - ``valshift`` -- a long giving the power of the uniformizer to shift `x` by.
    589603    -` ``prec`` -- a long, the precision of ``x``, used in rational
    590604                   reconstruction.
    591605    - ``prime_pow`` -- a PowComputer for the ring.
  • src/sage/libs/linkages/padics/fmpz_poly_unram.pxi

    diff --git a/src/sage/libs/linkages/padics/fmpz_poly_unram.pxi b/src/sage/libs/linkages/padics/fmpz_poly_unram.pxi
    index 3e27ed1b97..80b22e1c98 100644
    a b cdef clist(celement a, long prec, bint pos, PowComputer_ prime_pow): 
    570570# The element is filled in for zero in the output of clist if necessary.
    571571_list_zero = []
    572572
     573cdef list ccoefficients(celement x, long valshift, long prec, PowComputer_ prime_pow):
     574    """
     575    Return a list of coefficients, as elements that can be converted into the base ring.
     576
     577    INPUT:
     578
     579    - ``x`` -- a ``celement`` giving the underlying `p`-adic element, or possibly its unit part.
     580    - ``valshift`` -- a long giving the power of the uniformizer to shift `x` by.
     581    - ``prec`` -- a long, the (relative) precision desired, used in rational reconstruction
     582    - ``prime_pow`` -- the Powcomputer of the ring
     583    """
     584    cdef Integer ansz
     585    cdef Rational ansq
     586    cdef long i
     587    ans = []
     588    for i in range(fmpz_poly_length(x)):
     589        if valshift >= 0:
     590            ansz = PY_NEW(Integer)
     591            fmpz_poly_get_coeff_mpz(ansz.value, x, i)
     592            if valshift > 0:
     593                mpz_mul(ansz.value, ansz.value, prime_pow.pow_mpz_t_tmp(valshift))
     594            ans.append(ansz)
     595        else:
     596            ansq = Rational.__new__(Rational)
     597            fmpz_poly_get_coeff_mpz(mpq_numref(ansq.value), x, i)
     598            mpz_set(mpq_denref(ansq.value), prime_pow.pow_mpz_t_tmp(-valshift))
     599            mpq_canonicalize(ansq.value)
     600            ans.append(ansq)
     601    return ans
     602
    573603cdef int cteichmuller(celement out, celement value, long prec, PowComputer_ prime_pow) except -1:
    574604    """
    575605    Teichmuller lifting.
  • src/sage/libs/linkages/padics/mpz.pxi

    diff --git a/src/sage/libs/linkages/padics/mpz.pxi b/src/sage/libs/linkages/padics/mpz.pxi
    index 1c3694c376..158cc25042 100644
    a b cdef clist(mpz_t a, long prec, bint pos, PowComputer_ prime_pow): 
    539539# It could be [] for some other linkages.
    540540_list_zero = Integer(0)
    541541
     542cdef list ccoefficients(mpz_t x, long valshift, long prec, PowComputer_ prime_pow):
     543    """
     544    Return a list of coefficients, as elements that can be converted into the base ring.
     545
     546    INPUT:
     547
     548    - ``x`` -- a ``celement`` giving the underlying `p`-adic element, or possibly its unit part.
     549    - ``valshift`` -- a long giving the power of the uniformizer to shift `x` by.
     550    - ``prec`` -- a long, the (relative) precision desired, used in rational reconstruction
     551    - ``prime_pow`` -- the Powcomputer of the ring
     552    """
     553    cdef Integer ansz
     554    cdef Rational ansq
     555    if valshift >= 0:
     556        ansz = PY_NEW(Integer)
     557        cconv_mpz_t_out_shared(ansz.value, x, valshift, prec, prime_pow)
     558        return [ansz]
     559    else:
     560        ansq = Rational.__new__(Rational)
     561        cconv_mpq_t_out_shared(ansq.value, x, valshift, prec, prime_pow)
     562        return [ansq]
     563
    542564cdef int cteichmuller(mpz_t out, mpz_t value, long prec, PowComputer_ prime_pow) except -1:
    543565    """
    544566    Teichmuller lifting.
  • src/sage/libs/linkages/padics/unram_shared.pxi

    diff --git a/src/sage/libs/linkages/padics/unram_shared.pxi b/src/sage/libs/linkages/padics/unram_shared.pxi
    index ac07bd435a..d9f495e5aa 100644
    a b def frobenius_unram(self, arithmetic=True): 
    4949    frob_a = R._frob_gen()
    5050    ppow = self.valuation()
    5151    unit = self.unit_part()
    52     coefs = unit.list()
     52    coefs = unit.expansion()
    5353    ans = 0
    5454
    5555    # Xavier's implementation based on Horner scheme
  • src/sage/modular/btquotients/btquotient.py

    diff --git a/src/sage/modular/btquotients/btquotient.py b/src/sage/modular/btquotients/btquotient.py
    index 991f86240e..a74fe6843e 100644
    a b class BruhatTitsTree(SageObject, UniqueRepresentation): 
    986986        L = []
    987987        for ii in range(val):
    988988            L.append(0)
    989         L.extend(z.list())
     989        L.extend(z.expansion())
    990990        for n in range(len(L)):
    991991            if L[n] != 0:
    992992                if len(L[n]) > 1:
  • src/sage/rings/padics/CA_template.pxi

    diff --git a/src/sage/rings/padics/CA_template.pxi b/src/sage/rings/padics/CA_template.pxi
    index ab33ab87b5..9fae4335ce 100644
    a b from sage.rings.rational_field import QQ 
    4141from sage.categories.sets_cat import Sets
    4242from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
    4343from sage.categories.homset import Hom
     44from sage.misc.superseded import deprecated_function_alias, deprecation
    4445
    4546cdef class CAElement(pAdicTemplateElement):
    4647    cdef int _set(self, x, long val, long xprec, absprec, relprec) except -1:
    cdef class CAElement(pAdicTemplateElement): 
    734735            :meth:`sage.misc.cachefunc._cache_key`
    735736        """
    736737        tuple_recursive = lambda l: tuple(tuple_recursive(x) for x in l) if isinstance(l, list) else l
    737         return (self.parent(), tuple_recursive(self.list()), self.precision_absolute())
     738        return (self.parent(), tuple_recursive(self.expansion()), self.precision_absolute())
    738739
    739     def list(self, lift_mode = 'simple', start_val = None):
     740    def expansion(self, n = None, lift_mode = 'simple', start_val = None):
    740741        """
    741742        Returns a list of coefficients of `p` starting with `p^0`.
    742743
    cdef class CAElement(pAdicTemplateElement): 
    768769
    769770        INPUT:
    770771
     772        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     773          entry in the expansion.
     774
    771775        - ``lift_mode`` -- ``'simple'``, ``'smallest'`` or
    772776          ``'teichmuller'`` (default ``'simple'``)
    773777
    cdef class CAElement(pAdicTemplateElement): 
    784788
    785789            sage: R = ZpCA(7,6); a = R(12837162817); a
    786790            3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
    787             sage: L = a.list(); L
     791            sage: L = a.expansion(); L
    788792            [3, 4, 4, 0, 4]
    789793            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    790794            True
    791             sage: L = a.list('smallest'); L
     795            sage: L = a.expansion(lift_mode='smallest'); L
    792796            [3, -3, -2, 1, -3, 1]
    793797            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    794798            True
    795             sage: L = a.list('teichmuller'); L
     799            sage: L = a.expansion(lift_mode='teichmuller'); L
    796800            [3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5 + O(7^6),
    797801            O(7^5),
    798802            5 + 2*7 + 3*7^3 + O(7^4),
    cdef class CAElement(pAdicTemplateElement): 
    806810        with some zeros::
    807811
    808812            sage: a = R(7^3 * 17)
    809             sage: a.list()
     813            sage: a.expansion()
    810814            [0, 0, 0, 3, 2]
     815
     816        You can ask for a specific entry in the expansion::
     817
     818            sage: a = R(7^2 * 11)
     819            sage: a.expansion(2)
     820            4
     821            sage: a.expansion(2, lift_mode='smallest')
     822            -3
     823            sage: a.expansion(2, lift_mode='teichmuller')
     824            4 + 2*7 + 3*7^3 + O(7^4)
    811825        """
     826        if lift_mode == 'teichmuller':
     827            zero = self.parent()(0)
     828        else:
     829            # needs to be defined in the linkage file.
     830            zero = _list_zero
     831        if n in ('simple', 'smallest', 'teichmuller'):
     832            deprecation(14825, "Interface to expansion has changed; first argument now n")
     833            if not isinstance(lift_mode, basestring):
     834                start_val = lift_mode
     835            lift_mode = n
     836            n = None
     837        elif isinstance(n, slice):
     838            return self.slice(n.start, n.stop, n.step)
     839        elif n is not None:
     840            if n >= self.absprec:
     841                raise PrecisionError
     842            elif ciszero(self.value, self.prime_pow) or n < 0:
     843                return _list_zero
    812844        if ciszero(self.value, self.prime_pow):
    813845            return []
    814846        if lift_mode == 'teichmuller':
    815             vlist = self.teichmuller_list()
     847            if n is None:
     848                vlist = self.teichmuller_expansion()
     849            else:
     850                return self.teichmuller_expansion(n - self.valuation_c())
    816851        elif lift_mode == 'simple':
    817852            vlist = clist(self.value, self.absprec, True, self.prime_pow)
    818853        elif lift_mode == 'smallest':
    819854            vlist = clist(self.value, self.absprec, False, self.prime_pow)
    820855        else:
    821856            raise ValueError("unknown lift_mode")
     857        if n is not None:
     858            try:
     859                return vlist[n]
     860            except IndexError:
     861                return zero
    822862        if start_val is not None:
    823863            if start_val > 0:
    824864                if start_val > self.valuation_c():
    825865                    raise ValueError("starting valuation must be smaller than the element's valuation.  See slice()")
    826866                vlist = vlist[start_val:]
    827867            elif start_val < 0:
    828                 if lift_mode == 'teichmuller':
    829                     zero = self.parent()(0)
    830                 else:
    831                     # needs to be defined in the linkage file.
    832                     zero = _list_zero
    833868                vlist = [zero] * (-start_val) + vlist
    834869        return vlist
    835870
    836     def teichmuller_list(self):
     871    list = deprecated_function_alias(14825, expansion)
     872
     873    def teichmuller_expansion(self, n = None):
    837874        r"""
    838875        Returns a list `[a_0, a_1,\ldots, a_n]` such that
    839876
    840877        - `a_i^q = a_i`, where `q` is the cardinality of the residue field,
    841878
    842         - ``self`` equals `\sum_{i = 0}^n a_i \pi^i`, and
     879        - ``self.unit_part()`` equals `\sum_{i = 0}^n a_i \pi^i`, and
    843880
    844881        - if `a_i \ne 0`, the absolute precision of `a_i` is
    845882          ``self.precision_relative() - i``
    846883
     884        INPUT:
     885
     886        - ``n`` -- integer (default ``None``).  If given, returns the
     887          coefficient of `\pi^n` in the expansion (of the unit part).
     888
    847889        EXAMPLES::
    848890
    849             sage: R = ZpCA(5,5); R(14).list('teichmuller') #indirect doctest
     891            sage: R = ZpCA(5,6); R(70).expansion(lift_mode='teichmuller') #indirect doctest
    850892            [4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5),
    851893            3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4),
    852894            2 + 5 + 2*5^2 + O(5^3),
    853895            1 + O(5^2),
    854896            4 + O(5)]
     897            sage: R(70).teichmuller_expansion(1)
     898            3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4)
    855899        """
    856         ans = PyList_New(0)
    857         if ciszero(self.value, self.prime_pow):
    858             return ans
    859         cdef long curpower = self.absprec
    860900        cdef CAElement list_elt
     901        cdef long ordp
     902        if n is None:
     903            ans = PyList_New(0)
     904            if ciszero(self.value, self.prime_pow):
     905                return ans
     906            self = self.unit_part()
     907        elif n < 0:
     908            list_elt = self._new_c()
     909            csetzero(list_elt.value, self.prime_pow)
     910            list_elt.abspec = self.prime_pow.prec_cap
     911            return list_elt
     912        elif ciszero(self.value, self.prime_pow):
     913            raise PrecisionError
     914        else:
     915            self = self.unit_part()
     916            if n >= self.absprec:
     917                raise PrecisionError
     918            # We only need one list_elt
     919            list_elt = self._new_c()
     920        cdef long curpower = self.absprec
     921        cdef long goal
     922        if n is not None: goal = self.absprec - n
    861923        cdef CAElement tmp = self._new_c()
    862924        ccopy(tmp.value, self.value, self.prime_pow)
    863925        while not ciszero(tmp.value, tmp.prime_pow) and curpower > 0:
    864             list_elt = self._new_c()
     926            if n is None: list_elt = self._new_c()
    865927            cteichmuller(list_elt.value, tmp.value, curpower, self.prime_pow)
    866928            if ciszero(list_elt.value, self.prime_pow):
    867929                cshift_notrunc(tmp.value, tmp.value, -1, curpower-1, self.prime_pow)
    cdef class CAElement(pAdicTemplateElement): 
    870932                cshift_notrunc(tmp.value, tmp.value, -1, curpower-1, self.prime_pow)
    871933                creduce(tmp.value, tmp.value, curpower-1, self.prime_pow)
    872934            list_elt.absprec = curpower
     935            if n is None:
     936                PyList_Append(ans, list_elt)
     937            elif curpower == goal:
     938                return list_elt
    873939            curpower -= 1
    874             PyList_Append(ans, list_elt)
    875940        return ans
    876941
     942    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
     943
    877944    def _teichmuller_set_unsafe(self):
    878945        """
    879946        Sets this element to the Teichmuller representative with the
    cdef class CAElement(pAdicTemplateElement): 
    891958            11 + O(17^5)
    892959            sage: a._teichmuller_set_unsafe(); a
    893960            11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)
    894             sage: a.list('teichmuller')
     961            sage: a.expansion(lift_mode='teichmuller')
    895962            [11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)]
    896963
    897964        Note that if you set an element which is congruent to 0 you
    cdef class CAElement(pAdicTemplateElement): 
    910977        else:
    911978            cteichmuller(self.value, self.value, self.absprec, self.prime_pow)
    912979
     980    def polynomial(self, var='x'):
     981        """
     982        Returns a polynomial over the base ring that yields this element
     983        when evaluated at the generator of the parent.
     984
     985        INPUT:
     986
     987        - ``var`` -- string, the variable name for the polynomial
     988
     989        EXAMPLES::
     990
     991            sage: R.<a> = ZqCA(5^3)
     992            sage: a.polynomial()
     993            (1 + O(5^20))*x + (O(5^20))
     994            sage: a.polynomial(var='y')
     995            (1 + O(5^20))*y + (O(5^20))
     996            sage: (5*a^2 + R(25, 4)).polynomial()
     997            (5 + O(5^4))*x^2 + (O(5^4))*x + (5^2 + O(5^4))
     998        """
     999        R = self.base_ring()
     1000        S = R[var]
     1001        prec = self.precision_absolute()
     1002        e = self.parent().e()
     1003        L = ccoefficients(self.value, 0, self.absprec, self.prime_pow)
     1004        if e == 1:
     1005            L = [R(c, prec) for c in L]
     1006        else:
     1007            L = [R(c, (prec - i - 1) // e + 1) for i, c in enumerate(L)]
     1008        return S(L)
     1009
    9131010    def precision_absolute(self):
    9141011        """
    9151012        The absolute precision of this element.
    cdef class pAdicCoercion_ZZ_CA(RingHomomorphism): 
    10751172            True
    10761173        """
    10771174        _slots['_zero'] = self._zero
    1078         _slots['_section'] = self._section
     1175        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    10791176        return RingHomomorphism._extra_slots(self, _slots)
    10801177
    10811178    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_ZZ_CA(RingHomomorphism): 
    11731270            sage: f(ZpCA(5)(-1)) - 5^20
    11741271            -1
    11751272        """
     1273        from sage.misc.constant_function import ConstantFunction
     1274        if not isinstance(self._section.domain, ConstantFunction):
     1275            import copy
     1276            self._section = copy.copy(self._section)
    11761277        return self._section
    11771278
    11781279cdef class pAdicConvert_CA_ZZ(RingMap):
    cdef class pAdicCoercion_CA_frac_field(RingHomomorphism): 
    14661567            sage: f(K.gen())
    14671568            a + O(3^20)
    14681569        """
     1570        from sage.misc.constant_function import ConstantFunction
     1571        if not isinstance(self._section.domain, ConstantFunction):
     1572            import copy
     1573            self._section = copy.copy(self._section)
    14691574        return self._section
    14701575
    14711576    cdef dict _extra_slots(self, dict _slots):
    cdef class pAdicCoercion_CA_frac_field(RingHomomorphism): 
    14931598
    14941599        """
    14951600        _slots['_zero'] = self._zero
    1496         _slots['_section'] = self._section
     1601        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    14971602        return RingHomomorphism._extra_slots(self, _slots)
    14981603
    14991604    cdef _update_slots(self, dict _slots):
  • src/sage/rings/padics/CR_template.pxi

    diff --git a/src/sage/rings/padics/CR_template.pxi b/src/sage/rings/padics/CR_template.pxi
    index 14b295a5b5..33ab3b8c59 100644
    a b from sage.rings.rational_field import QQ 
    4141from sage.categories.sets_cat import Sets
    4242from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
    4343from sage.categories.homset import Hom
     44from sage.misc.superseded import deprecated_function_alias, deprecation
    4445
    4546cdef inline bint exactzero(long ordp):
    4647    """
    cdef class CRElement(pAdicTemplateElement): 
    11751176            :meth:`sage.misc.cachefunc._cache_key`
    11761177        """
    11771178        tuple_recursive = lambda l: tuple(tuple_recursive(x) for x in l) if isinstance(l, list) else l
    1178         return (self.parent(), tuple_recursive(self.list()), self.valuation(), self.precision_relative())
     1179        return (self.parent(), tuple_recursive(self.expansion()), self.valuation(), self.precision_relative())
    11791180
    1180     def list(self, lift_mode = 'simple', start_val = None):
     1181    def expansion(self, n = None, lift_mode = 'simple', start_val = None):
    11811182        """
    11821183        Returns a list of coefficients in a power series expansion of
    1183         self in terms of `\pi`.  If self is a field element, they start at
     1184        self in terms of the uniformizer `\pi`.  If this is a field element, they start at
    11841185        `\pi^{\mbox{valuation}}`, if a ring element at `\pi^0`.
    11851186
    11861187        For each lift mode, this function returns a list of `a_i` so
    cdef class CRElement(pAdicTemplateElement): 
    12111212
    12121213        INPUT:
    12131214
     1215        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     1216          entry in the expansion.
     1217
    12141218        - ``lift_mode`` -- ``'simple'``, ``'smallest'`` or
    12151219          ``'teichmuller'`` (default: ``'simple'``)
    12161220
    cdef class CRElement(pAdicTemplateElement): 
    12211225
    12221226        OUTPUT:
    12231227
    1224         - the list of coefficients of this element.  For base elements
    1225           these will be integers if ``lift_mode`` is ``'simple'`` or
    1226           ``'smallest'``, and elements of ``self.parent()`` if
    1227           ``lift_mode`` is ``'teichmuller'``.
     1228        - If ``n`` is ``None``, the `\pi`-adic expansion of this
     1229          element.  For base elements these will be integers if
     1230          ``lift_mode`` is ``'simple'`` or ``'smallest'``, and
     1231          elements of ``self.parent()`` if ``lift_mode`` is
     1232          ``'teichmuller'``.
     1233
     1234        - If ``n`` is an integer, the coefficient of `\pi^n` in the
     1235          `\pi`-adic expansion of this element.
    12281236
    12291237        .. NOTE::
    12301238
    cdef class CRElement(pAdicTemplateElement): 
    12341242
    12351243            sage: R = Zp(7,6); a = R(12837162817); a
    12361244            3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
    1237             sage: L = a.list(); L
     1245            sage: L = a.expansion(); L
    12381246            [3, 4, 4, 0, 4]
    12391247            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    12401248            True
    1241             sage: L = a.list('smallest'); L
     1249            sage: L = a.expansion(lift_mode='smallest'); L
    12421250            [3, -3, -2, 1, -3, 1]
    12431251            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    12441252            True
    1245             sage: L = a.list('teichmuller'); L
     1253            sage: L = a.expansion(lift_mode='teichmuller'); L
    12461254            [3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5 + O(7^6),
    12471255            0,
    12481256            5 + 2*7 + 3*7^3 + O(7^4),
    cdef class CRElement(pAdicTemplateElement): 
    12521260            sage: sum([L[i] * 7^i for i in range(len(L))])
    12531261            3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
    12541262
    1255             sage: R(0, 7).list()
     1263            sage: R(0, 7).expansion()
    12561264            []
    12571265
    1258             sage: R = Qp(7,4); a = R(6*7+7**2); a.list()
     1266            sage: R = Qp(7,4); a = R(6*7+7**2); a.expansion()
    12591267            [6, 1]
    1260             sage: a.list('smallest')
     1268            sage: a.expansion(lift_mode='smallest')
    12611269            [-1, 2]
    1262             sage: a.list('teichmuller')
     1270            sage: a.expansion(lift_mode='teichmuller')
    12631271            [6 + 6*7 + 6*7^2 + 6*7^3 + O(7^4),
    12641272            2 + 4*7 + 6*7^2 + O(7^3),
    12651273            3 + 4*7 + O(7^2),
    12661274            3 + O(7)]
    12671275
     1276        You can ask for a specific entry in the expansion::
     1277
     1278            sage: a.expansion(1)
     1279            6
     1280            sage: a.expansion(1, lift_mode='smallest')
     1281            -1
     1282            sage: a.expansion(2, lift_mode='teichmuller')
     1283            2 + 4*7 + 6*7^2 + O(7^3)
     1284
    12681285        TESTS:
    12691286
    12701287        Check to see that :trac:`10292` is resolved::
    12711288
    12721289            sage: E = EllipticCurve('37a')
    12731290            sage: R = E.padic_regulator(7)
    1274             sage: len(R.list())
     1291            sage: len(R.expansion())
    12751292            19
    12761293        """
     1294        if lift_mode == 'teichmuller':
     1295            zero = self.parent()(0)
     1296        else:
     1297            # needs to be defined in the linkage file.
     1298            zero = _list_zero
     1299        if n in ('simple', 'smallest', 'teichmuller'):
     1300            deprecation(14825, "Interface to expansion has changed; first argument now n")
     1301            if not isinstance(lift_mode, basestring):
     1302                start_val = lift_mode
     1303            lift_mode = n
     1304            n = None
     1305        elif isinstance(n, slice):
     1306            return self.slice(n.start, n.stop, n.step)
     1307        elif n is not None:
     1308            if exactzero(self.ordp) or n < self.ordp:
     1309                return zero
     1310            elif n >= self.ordp + self.relprec:
     1311                raise PrecisionError
    12771312        if start_val is not None and start_val > self.ordp:
    12781313            raise ValueError("starting valuation must be smaller than the element's valuation.  See slice()")
    1279         if self.relprec == 0:
     1314        if self.relprec == 0: # cannot have n = None
    12801315            return []
    12811316        if lift_mode == 'teichmuller':
    1282             ulist = self.teichmuller_list()
     1317            if n is None:
     1318                ulist = self.teichmuller_expansion()
     1319            else:
     1320                return self.teichmuller_expansion(n - self.ordp)
    12831321        elif lift_mode == 'simple':
    12841322            ulist = clist(self.unit, self.relprec, True, self.prime_pow)
    12851323        elif lift_mode == 'smallest':
    12861324            ulist = clist(self.unit, self.relprec, False, self.prime_pow)
    12871325        else:
    12881326            raise ValueError("unknown lift_mode")
     1327        if n is not None:
     1328            try:
     1329                return ulist[n - self.ordp]
     1330            except IndexError:
     1331                return zero
    12891332        if (self.prime_pow.in_field == 0 and self.ordp > 0) or start_val is not None:
    1290             if lift_mode == 'teichmuller':
    1291                 zero = self.parent()(0)
    1292             else:
    1293                 # needs to be defined in the linkage file.
    1294                 zero = _list_zero
    12951333            if start_val is None:
    12961334                v = self.ordp
    12971335            else:
    cdef class CRElement(pAdicTemplateElement): 
    12991337            ulist = [zero] * v + ulist
    13001338        return ulist
    13011339
    1302     def teichmuller_list(self):
     1340    list = deprecated_function_alias(14825, expansion)
     1341
     1342    def teichmuller_expansion(self, n = None):
    13031343        r"""
    13041344        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    13051345
    cdef class CRElement(pAdicTemplateElement): 
    13101350        - if `a_i \ne 0`, the absolute precision of `a_i` is
    13111351          self.precision_relative() - i
    13121352
     1353        INPUT:
     1354
     1355        - ``n`` -- integer (default ``None``).  If given, returns the
     1356          coefficient of `\pi^n` in the expansion (of the unit part).
     1357
    13131358        EXAMPLES::
    13141359
    1315             sage: R = Qp(5,5); R(70).list('teichmuller') #indirect doctest
     1360            sage: R = Qp(5,5); R(70).expansion(lift_mode='teichmuller') #indirect doctest
    13161361            [4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5),
    13171362            3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4),
    13181363            2 + 5 + 2*5^2 + O(5^3),
    13191364            1 + O(5^2),
    13201365            4 + O(5)]
     1366            sage: R(70).teichmuller_expansion(1)
     1367            3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4)
    13211368        """
    1322         ans = PyList_New(0)
    1323         if self.relprec == 0:
    1324             return ans
    1325         cdef long curpower = self.relprec
    13261369        cdef CRElement list_elt
     1370        if n is None:
     1371            ans = PyList_New(0)
     1372            if self.relprec == 0:
     1373                return ans
     1374        elif exactzero(self.ordp) or n < 0:
     1375            list_elt = self._new_c()
     1376            list_elt._set_exact_zero()
     1377            return list_elt
     1378        elif n >= self.relprec:
     1379            raise PrecisionError
     1380        else:
     1381            # We only need one list_elt
     1382            list_elt = self._new_c()
     1383        cdef long curpower = self.relprec
     1384        cdef long goal
     1385        if n is not None: goal = self.relprec - n
    13271386        cdef CRElement tmp = self._new_c()
    13281387        ccopy(tmp.unit, self.unit, self.prime_pow)
    13291388        while not ciszero(tmp.unit, tmp.prime_pow) and curpower > 0:
    1330             list_elt = self._new_c()
     1389            if n is None: list_elt = self._new_c()
    13311390            cteichmuller(list_elt.unit, tmp.unit, curpower, self.prime_pow)
    13321391            if ciszero(list_elt.unit, self.prime_pow):
    13331392                list_elt._set_exact_zero()
    cdef class CRElement(pAdicTemplateElement): 
    13381397                csub(tmp.unit, tmp.unit, list_elt.unit, curpower, self.prime_pow)
    13391398                cshift_notrunc(tmp.unit, tmp.unit, -1, curpower-1, self.prime_pow)
    13401399                creduce(tmp.unit, tmp.unit, curpower-1, self.prime_pow)
     1400            if n is None:
     1401                PyList_Append(ans, list_elt)
     1402            elif curpower == goal:
     1403                return list_elt
    13411404            curpower -= 1
    1342             PyList_Append(ans, list_elt)
    13431405        return ans
    13441406
     1407    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
     1408
    13451409    def _teichmuller_set_unsafe(self):
    13461410        """
    13471411        Sets this element to the Teichmuller representative with the
    cdef class CRElement(pAdicTemplateElement): 
    13591423            11 + O(17^5)
    13601424            sage: a._teichmuller_set_unsafe(); a
    13611425            11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)
    1362             sage: a.list('teichmuller')
     1426            sage: a.expansion(lift_mode='teichmuller')
    13631427            [11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)]
    13641428
    13651429        Note that if you set an element which is congruent to 0 you
    cdef class CRElement(pAdicTemplateElement): 
    13791443        else:
    13801444            cteichmuller(self.unit, self.unit, self.relprec, self.prime_pow)
    13811445
     1446    def polynomial(self, var='x'):
     1447        """
     1448        Returns a polynomial over the base ring that yields this element
     1449        when evaluated at the generator of the parent.
     1450
     1451        INPUT:
     1452
     1453        - ``var`` -- string, the variable name for the polynomial
     1454
     1455        EXAMPLES::
     1456
     1457            sage: K.<a> = Qq(5^3)
     1458            sage: a.polynomial()
     1459            (1 + O(5^20))*x + (O(5^20))
     1460            sage: a.polynomial(var='y')
     1461            (1 + O(5^20))*y + (O(5^20))
     1462            sage: (5*a^2 + K(25, 4)).polynomial()
     1463            (5 + O(5^4))*x^2 + (O(5^4))*x + (5^2 + O(5^4))
     1464        """
     1465        R = self.base_ring()
     1466        S = R[var]
     1467        if exactzero(self.ordp):
     1468            return S([])
     1469        else:
     1470            prec = self.precision_absolute()
     1471            e = self.parent().e()
     1472            L = ccoefficients(self.unit, self.ordp, self.relprec, self.prime_pow)
     1473            if e == 1:
     1474                L = [R(c, prec) for c in L]
     1475            else:
     1476                L = [R(c, (prec - i - 1) // e + 1) for i, c in enumerate(L)]
     1477            return S(L)
     1478
    13821479    def precision_absolute(self):
    13831480        """
    13841481        Returns the absolute precision of this element.
    cdef class pAdicCoercion_ZZ_CR(RingHomomorphism): 
    16091706
    16101707        """
    16111708        _slots['_zero'] = self._zero
    1612         _slots['_section'] = self._section
     1709        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    16131710        return RingHomomorphism._extra_slots(self, _slots)
    16141711
    16151712    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_ZZ_CR(RingHomomorphism): 
    17131810            sage: f(Zp(5)(-1)) - 5^20
    17141811            -1
    17151812        """
     1813        from sage.misc.constant_function import ConstantFunction
     1814        if not isinstance(self._section.domain, ConstantFunction):
     1815            import copy
     1816            self._section = copy.copy(self._section)
    17161817        return self._section
    17171818
    17181819cdef class pAdicConvert_CR_ZZ(RingMap):
    cdef class pAdicCoercion_QQ_CR(RingHomomorphism): 
    18231924
    18241925        """
    18251926        _slots['_zero'] = self._zero
    1826         _slots['_section'] = self._section
     1927        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    18271928        return RingHomomorphism._extra_slots(self, _slots)
    18281929
    18291930    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_QQ_CR(RingHomomorphism): 
    19332034            sage: f(Qp(5)(1/5))
    19342035            1/5
    19352036        """
     2037        from sage.misc.constant_function import ConstantFunction
     2038        if not isinstance(self._section.domain, ConstantFunction):
     2039            import copy
     2040            self._section = copy.copy(self._section)
    19362041        return self._section
    19372042
    19382043cdef class pAdicConvert_CR_QQ(RingMap):
    cdef class pAdicConvert_QQ_CR(Morphism): 
    20262131            True
    20272132        """
    20282133        _slots['_zero'] = self._zero
    2029         _slots['_section'] = self._section
     2134        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    20302135        return Morphism._extra_slots(self, _slots)
    20312136
    20322137    cdef _update_slots(self, dict _slots):
    cdef class pAdicConvert_QQ_CR(Morphism): 
    21322237            sage: f(Zp(5,4)(-1))
    21332238            -1
    21342239        """
     2240        from sage.misc.constant_function import ConstantFunction
     2241        if not isinstance(self._section.domain, ConstantFunction):
     2242            import copy
     2243            self._section = copy.copy(self._section)
    21352244        return self._section
    21362245
    21372246cdef class pAdicCoercion_CR_frac_field(RingHomomorphism):
    cdef class pAdicCoercion_CR_frac_field(RingHomomorphism): 
    22532362            sage: f(K.gen())
    22542363            a + O(3^20)
    22552364        """
     2365        from sage.misc.constant_function import ConstantFunction
     2366        if not isinstance(self._section.domain, ConstantFunction):
     2367            import copy
     2368            self._section = copy.copy(self._section)
    22562369        return self._section
    22572370
    22582371    cdef dict _extra_slots(self, dict _slots):
    cdef class pAdicCoercion_CR_frac_field(RingHomomorphism): 
    22802393
    22812394        """
    22822395        _slots['_zero'] = self._zero
    2283         _slots['_section'] = self._section
     2396        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    22842397        return RingHomomorphism._extra_slots(self, _slots)
    22852398
    22862399    cdef _update_slots(self, dict _slots):
  • src/sage/rings/padics/FM_template.pxi

    diff --git a/src/sage/rings/padics/FM_template.pxi b/src/sage/rings/padics/FM_template.pxi
    index 4f72ea20ee..14cd3cacb8 100644
    a b from sage.rings.rational_field import QQ 
    4343from sage.categories.sets_cat import Sets
    4444from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
    4545from sage.categories.homset import Hom
     46from sage.misc.superseded import deprecated_function_alias, deprecation
    4647
    4748cdef class FMElement(pAdicTemplateElement):
    4849    cdef int _set(self, x, long val, long xprec, absprec, relprec) except -1:
    cdef class FMElement(pAdicTemplateElement): 
    581582        """
    582583        return self
    583584
    584     def list(self, lift_mode = 'simple'):
    585         r"""
    586         Returns a list of coefficients of `\pi^i` starting with `\pi^0`.
     585    def expansion(self, n = None, lift_mode = 'simple'):
     586        r"""Returns a list of coefficients of `\pi^i` starting with `\pi^0`.
    587587
    588588        INPUT:
    589589
     590        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     591          entry in the expansion.
     592
    590593        - ``lift_mode`` -- ``'simple'``, ``'smallest'`` or ``'teichmuller'``
    591594          (default: ``'simple'``:)
    592595
    593596        OUTPUT:
    594597
    595         The list of coefficients of this element.
     598        - If ``n`` is ``None``, the `\pi`-adic expansion of this
     599          element.  For base elements these will be integers if
     600          ``lift_mode`` is ``'simple'`` or ``'smallest'``, and
     601          elements of ``self.parent()`` if ``lift_mode`` is
     602          ``'teichmuller'``.
     603
     604        - If ``n`` is an integer, the coefficient of `\pi^n` in the
     605          `\pi`-adic expansion of this element.
    596606
    597607        .. NOTE::
    598608
    cdef class FMElement(pAdicTemplateElement): 
    611621
    612622            sage: R = ZpFM(7,6); a = R(12837162817); a
    613623            3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
    614             sage: L = a.list(); L
     624            sage: L = a.expansion(); L
    615625            [3, 4, 4, 0, 4]
    616626            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    617627            True
    618             sage: L = a.list('smallest'); L
     628            sage: L = a.expansion(lift_mode='smallest'); L
    619629            [3, -3, -2, 1, -3, 1]
    620630            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    621631            True
    622             sage: L = a.list('teichmuller'); L
     632            sage: L = a.expansion(lift_mode='teichmuller'); L
    623633            [3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5 + O(7^6),
    624634            O(7^6),
    625635            5 + 2*7 + 3*7^3 + 6*7^4 + 4*7^5 + O(7^6),
    cdef class FMElement(pAdicTemplateElement): 
    628638            5 + 2*7 + 3*7^3 + 6*7^4 + 4*7^5 + O(7^6)]
    629639            sage: sum([L[i] * 7^i for i in range(len(L))])
    630640            3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
    631         """
     641
     642        You can ask for a specific entry in the expansion::
     643
     644            sage: a.expansion(1)
     645            4
     646            sage: a.expansion(1, lift_mode='smallest')
     647            -3
     648            sage: a.expansion(2, lift_mode='teichmuller')
     649            5 + 2*7 + 3*7^3 + 6*7^4 + 4*7^5 + O(7^6)
     650        """
     651        if n in ('simple', 'smallest', 'teichmuller'):
     652            deprecation(14825, "Interface to expansion has changed; first argument now n")
     653            lift_mode = n
     654            n = None
     655        elif isinstance(n, slice):
     656            return self.slice(n.start, n.stop, n.step)
     657        elif n is not None and (ciszero(self.value, self.prime_pow) or n < 0 or n >= self.prime_pow.prec_cap):
     658            return _list_zero
    632659        if ciszero(self.value, self.prime_pow):
    633660            return []
    634661        if lift_mode == 'teichmuller':
    635             return self.teichmuller_list()
     662            if n is None:
     663                return self.teichmuller_expansion()
     664            else:
     665                return self.teichmuller_expansion(n - self.valuation_c())
    636666        elif lift_mode == 'simple':
    637             return clist(self.value, self.prime_pow.prec_cap, True, self.prime_pow)
     667            vlist = clist(self.value, self.prime_pow.prec_cap, True, self.prime_pow)
    638668        elif lift_mode == 'smallest':
    639             return clist(self.value, self.prime_pow.prec_cap, False, self.prime_pow)
     669            vlist = clist(self.value, self.prime_pow.prec_cap, False, self.prime_pow)
    640670        else:
    641671            raise ValueError("unknown lift_mode")
     672        if n is None:
     673            return vlist
     674        else:
     675            try:
     676                return vlist[n]
     677            except IndexError:
     678                return _list_zero
     679
     680    list = deprecated_function_alias(14825, expansion)
    642681
    643     def teichmuller_list(self):
     682    def teichmuller_expansion(self, n = None):
    644683        r"""
    645684        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    646685
    cdef class FMElement(pAdicTemplateElement): 
    648687
    649688        - self.unit_part() = `\sum_{i = 0}^n a_i \pi^i`
    650689
     690        INPUT:
     691
     692        - ``n`` -- integer (default ``None``).  If given, returns the
     693          coefficient of `\pi^n` in the expansion (of the unit part).
     694
    651695        EXAMPLES::
    652696
    653             sage: R = ZpFM(5,5); R(14).list('teichmuller') #indirect doctest
     697            sage: R = ZpFM(5,5); R(70).expansion(lift_mode='teichmuller') #indirect doctest
    654698            [4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5),
    655699            3 + 3*5 + 2*5^2 + 3*5^3 + 5^4 + O(5^5),
    656700            2 + 5 + 2*5^2 + 5^3 + 3*5^4 + O(5^5),
    657701            1 + O(5^5),
    658702            4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5)]
     703            sage: R(70).teichmuller_expansion(1)
     704            3 + 3*5 + 2*5^2 + 3*5^3 + 5^4 + O(5^5)
    659705        """
    660         ans = PyList_New(0)
    661         if ciszero(self.value, self.prime_pow):
    662             return ans
     706        cdef FMElement list_elt
     707        if n is None:
     708            ans = PyList_New(0)
     709            if ciszero(self.value, self.prime_pow):
     710                return ans
     711        elif ciszero(self.value, self.prime_pow) or n < 0 or n >= self.prime_pow.prec_cap:
     712            list_elt = self._new_c()
     713            csetzero(list_elt.value, self.prime_pow)
     714            return list_elt
     715        else:
     716            # We only need one list_elt
     717            list_elt = self._new_c()
     718        self = self.unit_part()
    663719        cdef long curpower = self.prime_pow.prec_cap
    664720        cdef long prec_cap = self.prime_pow.prec_cap
    665         cdef FMElement list_elt
     721        cdef long goal
     722        if n is not None: goal = prec_cap - n
    666723        cdef FMElement tmp = self._new_c()
    667724        ccopy(tmp.value, self.value, self.prime_pow)
    668725        while not ciszero(tmp.value, tmp.prime_pow) and curpower > 0:
    669             list_elt = self._new_c()
     726            if n is None: list_elt = self._new_c()
    670727            cteichmuller(list_elt.value, tmp.value, prec_cap, self.prime_pow)
    671728            if ciszero(list_elt.value, self.prime_pow):
    672729                cshift_notrunc(tmp.value, tmp.value, -1, prec_cap, self.prime_pow)
    cdef class FMElement(pAdicTemplateElement): 
    674731                csub(tmp.value, tmp.value, list_elt.value, prec_cap, self.prime_pow)
    675732                cshift_notrunc(tmp.value, tmp.value, -1, prec_cap, self.prime_pow)
    676733                creduce(tmp.value, tmp.value, prec_cap, self.prime_pow)
     734            if n is None:
     735                PyList_Append(ans, list_elt)
     736            elif curpower == goal:
     737                return list_elt
    677738            curpower -= 1
    678             PyList_Append(ans, list_elt)
    679739        return ans
    680740
     741    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
     742
    681743    def _teichmuller_set_unsafe(self):
    682744        """
    683745        Sets this element to the Teichmuller representative with the
    cdef class FMElement(pAdicTemplateElement): 
    695757            11 + O(17^5)
    696758            sage: a._teichmuller_set_unsafe(); a
    697759            11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)
    698             sage: a.list('teichmuller')
     760            sage: a.expansion(lift_mode='teichmuller')
    699761            [11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4 + O(17^5)]
    700762
    701763        Note that if you set an element which is congruent to 0 you
    cdef class FMElement(pAdicTemplateElement): 
    711773        else:
    712774            csetzero(self.value, self.prime_pow)
    713775
     776    def polynomial(self, var='x'):
     777        """
     778        Returns a polynomial over the base ring that yields this element
     779        when evaluated at the generator of the parent.
     780
     781        INPUT:
     782
     783        - ``var`` -- string, the variable name for the polynomial
     784
     785        EXAMPLES::
     786
     787            sage: R.<a> = ZqFM(5^3)
     788            sage: a.polynomial()
     789            (1 + O(5^20))*x + (O(5^20))
     790            sage: a.polynomial(var='y')
     791            (1 + O(5^20))*y + (O(5^20))
     792            sage: (5*a^2 + 25).polynomial()
     793            (5 + O(5^20))*x^2 + (O(5^20))*x + (5^2 + O(5^20))
     794        """
     795        R = self.base_ring()
     796        S = R[var]
     797        prec = self.precision_absolute()
     798        e = self.parent().e()
     799        L = ccoefficients(self.value, 0, self.prime_pow.prec_cap, self.prime_pow)
     800        if e == 1:
     801            L = [R(c, prec) for c in L]
     802        else:
     803            L = [R(c, (prec - i - 1) // e + 1) for i, c in enumerate(L)]
     804        return S(L)
     805
    714806    def precision_absolute(self):
    715807        """
    716808        The absolute precision of this element.
    cdef class pAdicCoercion_ZZ_FM(RingHomomorphism): 
    873965            True
    874966        """
    875967        _slots['_zero'] = self._zero
    876         _slots['_section'] = self._section
     968        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    877969        return RingHomomorphism._extra_slots(self, _slots)
    878970
    879971    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_ZZ_FM(RingHomomorphism): 
    9631055            sage: f(ZpFM(5)(-1)) - 5^20
    9641056            -1
    9651057        """
     1058        from sage.misc.constant_function import ConstantFunction
     1059        if not isinstance(self._section.domain, ConstantFunction):
     1060            import copy
     1061            self._section = copy.copy(self._section)
    9661062        return self._section
    9671063
    9681064cdef class pAdicConvert_FM_ZZ(RingMap):
  • src/sage/rings/padics/FP_template.pxi

    diff --git a/src/sage/rings/padics/FP_template.pxi b/src/sage/rings/padics/FP_template.pxi
    index af4f0d40db..6a01848453 100644
    a b from sage.rings.rational_field import QQ 
    4444from sage.categories.sets_cat import Sets
    4545from sage.categories.sets_with_partial_maps import SetsWithPartialMaps
    4646from sage.categories.homset import Hom
     47from sage.misc.superseded import deprecated_function_alias, deprecation
    4748
    4849cdef inline bint overunderflow(long* ordp, celement unit, PowComputer_ prime_pow):
    4950    """
    cdef class FPElement(pAdicTemplateElement): 
    895896        """
    896897        return self
    897898
    898     def list(self, lift_mode = 'simple', start_val = None):
     899    def expansion(self, n = None, lift_mode = 'simple', start_val = None):
    899900        r"""
    900901        Returns a list of coefficients in a power series expansion of
    901902        this element in terms of `\pi`.  If this is a field element,
    902903        they start at `\pi^{\mbox{valuation}}`, if a ring element at `\pi^0`.
    903904
     905        NOTES:
     906
    904907        For each lift mode, this function returns a list of `a_i` so
    905908        that this element can be expressed as
    906909
    cdef class FPElement(pAdicTemplateElement): 
    929932
    930933        INPUT:
    931934
     935        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     936          entry in the expansion.
     937
    932938        - ``lift_mode`` -- ``'simple'``, ``'smallest'`` or
    933939          ``'teichmuller'`` (default: ``'simple'``)
    934940
    cdef class FPElement(pAdicTemplateElement): 
    939945
    940946        OUTPUT:
    941947
    942         - the list of coefficients of this element.  For base elements
    943           these will be integers if ``lift_mode`` is ``'simple'`` or
    944           ``'smallest'``, and elements of ``self.parent()`` if
    945           ``lift_mode`` is ``'teichmuller'``.
     948        - If ``n`` is ``None``, the `\pi`-adic expansion of this
     949          element.  For base elements these will be integers if
     950          ``lift_mode`` is ``'simple'`` or ``'smallest'``, and
     951          elements of ``self.parent()`` if ``lift_mode`` is
     952          ``'teichmuller'``.
     953
     954        - If ``n`` is an integer, the coefficient of `\pi^n` in the
     955          `\pi`-adic expansion of this element.
    946956
    947957        .. NOTE::
    948958
    cdef class FPElement(pAdicTemplateElement): 
    952962
    953963            sage: R = ZpFP(7,6); a = R(12837162817); a
    954964            3 + 4*7 + 4*7^2 + 4*7^4
    955             sage: L = a.list(); L
     965            sage: L = a.expansion(); L
    956966            [3, 4, 4, 0, 4]
    957967            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    958968            True
    959             sage: L = a.list('smallest'); L
     969            sage: L = a.expansion(lift_mode='smallest'); L
    960970            [3, -3, -2, 1, -3, 1]
    961971            sage: sum([L[i] * 7^i for i in range(len(L))]) == a
    962972            True
    963             sage: L = a.list('teichmuller'); L
     973            sage: L = a.expansion(lift_mode='teichmuller'); L
    964974            [3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5,
    965975            0,
    966976            5 + 2*7 + 3*7^3 + 6*7^4 + 4*7^5,
    cdef class FPElement(pAdicTemplateElement): 
    970980            sage: sum([L[i] * 7^i for i in range(len(L))])
    971981            3 + 4*7 + 4*7^2 + 4*7^4
    972982
    973             sage: R(0).list()
     983            sage: R(0).expansion()
    974984            []
    975985
    976             sage: R = QpFP(7,4); a = R(6*7+7**2); a.list()
     986            sage: R = QpFP(7,4); a = R(6*7+7**2); a.expansion()
    977987            [6, 1]
    978             sage: a.list('smallest')
     988            sage: a.expansion(lift_mode='smallest')
    979989            [-1, 2]
    980             sage: a.list('teichmuller')
     990            sage: a.expansion(lift_mode='teichmuller')
    981991            [6 + 6*7 + 6*7^2 + 6*7^3,
    982992            2 + 4*7 + 6*7^2 + 3*7^3,
    983993            3 + 4*7 + 6*7^2 + 3*7^3,
    984994            3 + 4*7 + 6*7^2 + 3*7^3]
     995
     996        You can ask for a specific entry in the expansion::
     997
     998            sage: a.expansion(1)
     999            6
     1000            sage: a.expansion(1, lift_mode='smallest')
     1001            -1
     1002            sage: a.expansion(2, lift_mode='teichmuller')
     1003            2 + 4*7 + 6*7^2 + 3*7^3
    9851004        """
    9861005        R = self.parent()
     1006        if lift_mode == 'teichmuller':
     1007            zero = R(0)
     1008        else:
     1009            # needs to be defined in the linkage file.
     1010            zero = _list_zero
     1011        if n in ('simple', 'smallest', 'teichmuller'):
     1012            deprecation(14825, "Interface to expansion has changed; first argument now n")
     1013            if not isinstance(lift_mode, basestring):
     1014                start_val = lift_mode
     1015            lift_mode = n
     1016            n = None
     1017        elif isinstance(n, slice):
     1018            return self.slice(n.start, n.stop, n.step)
     1019        elif n is not None and (huge_val(self.ordp) or n < self.ordp or n >= self.ordp + self.prime_pow.prec_cap):
     1020            return zero
    9871021        if start_val is not None and start_val > self.ordp:
    9881022            raise ValueError("starting valuation must be smaller than the element's valuation.  See slice()")
    989         if very_pos_val(self.ordp):
     1023        if huge_val(self.ordp):
    9901024            return []
    991         elif very_neg_val(self.ordp):
    992             if lift_mode == 'teichmuller':
    993                 return [R(1)]
    994             elif R.f() == 1:
    995                 return [ZZ(1)]
    996             else:
    997                 return [[ZZ(1)]]
    9981025        if lift_mode == 'teichmuller':
    999             ulist = self.teichmuller_list()
     1026            if n is None:
     1027                ulist = self.teichmuller_expansion()
     1028            else:
     1029                return self.teichmuller_expansion(n - self.ordp)
    10001030        elif lift_mode == 'simple':
    10011031            ulist = clist(self.unit, self.prime_pow.prec_cap, True, self.prime_pow)
    10021032        elif lift_mode == 'smallest':
    10031033            ulist = clist(self.unit, self.prime_pow.prec_cap, False, self.prime_pow)
    10041034        else:
    10051035            raise ValueError("unknown lift_mode")
     1036        if n is not None:
     1037            try:
     1038                return ulist[n - self.ordp]
     1039            except IndexError:
     1040                return zero
    10061041        if (self.prime_pow.in_field == 0 and self.ordp > 0) or start_val is not None:
    1007             if lift_mode == 'teichmuller':
    1008                 zero = R(0)
    1009             else:
    1010                 # needs to be defined in the linkage file.
    1011                 zero = _list_zero
    10121042            if start_val is None:
    10131043                v = self.ordp
    10141044            else:
    cdef class FPElement(pAdicTemplateElement): 
    10161046            ulist = [zero] * v + ulist
    10171047        return ulist
    10181048
    1019     def teichmuller_list(self):
     1049    list = deprecated_function_alias(14825, expansion)
     1050
     1051    def teichmuller_expansion(self, n = None):
    10201052        r"""
    10211053        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    10221054
    cdef class FPElement(pAdicTemplateElement): 
    10241056
    10251057        - self.unit_part() = `\sum_{i = 0}^n a_i \pi^i`
    10261058
     1059        INPUT:
     1060
     1061        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     1062          entry in the expansion.
     1063
    10271064        EXAMPLES::
    10281065
    1029             sage: R = ZpFP(5,5); R(14).list('teichmuller') #indirect doctest
     1066            sage: R = ZpFP(5,5); R(70).teichmuller_expansion()
    10301067            [4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4,
    10311068            3 + 3*5 + 2*5^2 + 3*5^3 + 5^4,
    10321069            2 + 5 + 2*5^2 + 5^3 + 3*5^4,
    10331070            1,
    10341071            4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4]
     1072            sage: R(70).teichmuller_expansion(2)
     1073            2 + 5 + 2*5^2 + 5^3 + 3*5^4
    10351074        """
    10361075        cdef FPElement list_elt
    1037         ans = PyList_New(0)
    1038         if very_pos_val(self.ordp):
    1039             return ans
    1040         if very_neg_val(self.ordp):
     1076        if n is None:
     1077            ans = PyList_New(0)
     1078            if huge_val(self.ordp):
     1079                return ans
     1080        elif huge_val(self.ordp) or n < self.ordp or n >= self.ordp + self.prime_pow.prec_cap:
     1081            list_elt = self._new_c()
     1082            list_elt._set_exact_zero()
     1083            return list_elt
     1084        else:
     1085            # We only need one list_elt
    10411086            list_elt = self._new_c()
    1042             csetone(list_elt.unit, self.prime_pow)
    1043             list_elt.ordp = 0
    1044             PyList_Append(ans, list_elt)
    1045             return ans
    10461087        cdef long prec_cap = self.prime_pow.prec_cap
     1088        cdef long goal
     1089        if n is not None: goal = prec_cap - n
    10471090        cdef long curpower = prec_cap
    10481091        cdef FPElement tmp = self._new_c()
    10491092        ccopy(tmp.unit, self.unit, self.prime_pow)
    10501093        while not ciszero(tmp.unit, tmp.prime_pow) and curpower > 0:
    1051             list_elt = self._new_c()
     1094            if n is None: list_elt = self._new_c()
    10521095            cteichmuller(list_elt.unit, tmp.unit, prec_cap, self.prime_pow)
    10531096            if ciszero(list_elt.unit, self.prime_pow):
    10541097                list_elt.ordp = maxordp
    cdef class FPElement(pAdicTemplateElement): 
    10581101                csub(tmp.unit, tmp.unit, list_elt.unit, prec_cap, self.prime_pow)
    10591102                cshift_notrunc(tmp.unit, tmp.unit, -1, prec_cap, self.prime_pow)
    10601103                creduce(tmp.unit, tmp.unit, prec_cap, self.prime_pow)
     1104            if n is None:
     1105                PyList_Append(ans, list_elt)
     1106            elif curpower == goal:
     1107                return list_elt
    10611108            curpower -= 1
    1062             PyList_Append(ans, list_elt)
    10631109        return ans
    10641110
     1111    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
     1112
    10651113    def _teichmuller_set_unsafe(self):
    10661114        """
    10671115        Sets this element to the Teichmuller representative with the
    cdef class FPElement(pAdicTemplateElement): 
    10791127            11
    10801128            sage: a._teichmuller_set_unsafe(); a
    10811129            11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4
    1082             sage: a.list('teichmuller')
     1130            sage: a.expansion(lift_mode='teichmuller')
    10831131            [11 + 14*17 + 2*17^2 + 12*17^3 + 15*17^4]
    10841132
    10851133        Note that if you set an element which is congruent to 0 you
    cdef class FPElement(pAdicTemplateElement): 
    10971145        else:
    10981146            cteichmuller(self.unit, self.unit, self.prime_pow.prec_cap, self.prime_pow)
    10991147
     1148    def polynomial(self, var='x'):
     1149        """
     1150        Returns a polynomial over the base ring that yields this element
     1151        when evaluated at the generator of the parent.
     1152
     1153        INPUT:
     1154
     1155        - ``var`` -- string, the variable name for the polynomial
     1156
     1157        EXAMPLES::
     1158
     1159            sage: K.<a> = QqFP(5^3)
     1160            sage: a.polynomial()
     1161            x
     1162            sage: a.polynomial(var='y')
     1163            y
     1164            sage: (5*a^2 + K(25, 4)).polynomial()
     1165            5*x^2 + 5^2
     1166        """
     1167        R = self.base_ring()
     1168        S = R[var]
     1169        if very_pos_val(self.ordp):
     1170            return S([])
     1171        elif very_neg_val(self.ordp):
     1172            return S([~R(0)])
     1173        else:
     1174            return S(ccoefficients(self.unit, self.ordp, self.prime_pow.ram_prec_cap, self.prime_pow))
     1175
    11001176    def precision_absolute(self):
    11011177        """
    11021178        The absolute precision of this element.
    cdef class pAdicCoercion_ZZ_FP(RingHomomorphism): 
    12951371            True
    12961372        """
    12971373        _slots['_zero'] = self._zero
    1298         _slots['_section'] = self._section
     1374        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    12991375        return RingHomomorphism._extra_slots(self, _slots)
    13001376
    13011377    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_ZZ_FP(RingHomomorphism): 
    13921468            sage: f(ZpFP(5)(-1)) - 5^20
    13931469            -1
    13941470        """
     1471        from sage.misc.constant_function import ConstantFunction
     1472        if not isinstance(self._section.domain, ConstantFunction):
     1473            import copy
     1474            self._section = copy.copy(self._section)
    13951475        return self._section
    13961476
    13971477cdef class pAdicConvert_FP_ZZ(RingMap):
    cdef class pAdicCoercion_QQ_FP(RingHomomorphism): 
    15071587            True
    15081588        """
    15091589        _slots['_zero'] = self._zero
    1510         _slots['_section'] = self._section
     1590        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    15111591        return RingHomomorphism._extra_slots(self, _slots)
    15121592
    15131593    cdef _update_slots(self, dict _slots):
    cdef class pAdicCoercion_QQ_FP(RingHomomorphism): 
    16091689            sage: f(QpFP(5)(1/5))
    16101690            1/5
    16111691        """
     1692        from sage.misc.constant_function import ConstantFunction
     1693        if not isinstance(self._section.domain, ConstantFunction):
     1694            import copy
     1695            self._section = copy.copy(self._section)
    16121696        return self._section
    16131697
    16141698cdef class pAdicConvert_FP_QQ(RingMap):
    cdef class pAdicCoercion_FP_frac_field(RingHomomorphism): 
    19282012
    19292013        """
    19302014        _slots['_zero'] = self._zero
    1931         _slots['_section'] = self._section
     2015        _slots['_section'] = self.section() # use method since it copies coercion-internal sections.
    19322016        return RingHomomorphism._extra_slots(self, _slots)
    19332017
    19342018    cdef _update_slots(self, dict _slots):
  • src/sage/rings/padics/local_generic_element.pyx

    diff --git a/src/sage/rings/padics/local_generic_element.pyx b/src/sage/rings/padics/local_generic_element.pyx
    index f2fb220e4b..1c7b1ccf00 100644
    a b cdef class LocalGenericElement(CommutativeRingElement): 
    257257            sage: x.slice(None, 3)
    258258            5^-2 + 5 + O(5^3)
    259259            sage: x[:3]
     260            doctest:warning
     261            ...
     262            DeprecationWarning: __getitem__ is changing to match the behavior of number fields. Please use expansion instead.
     263            See http://trac.sagemath.org/14825 for details.
    260264            5^-2 + 5 + O(5^3)
    261265
    262266        TESTS:
    cdef class LocalGenericElement(CommutativeRingElement): 
    332336
    333337        # construct the return value
    334338        ans = self.parent().zero()
    335         for c in self.list()[start:stop:k]:
     339        for c in self.expansion()[start:stop:k]:
    336340            ans += ppow * c
    337341            ppow *= pk
    338342
  • src/sage/rings/padics/padic_ZZ_pX_CA_element.pyx

    diff --git a/src/sage/rings/padics/padic_ZZ_pX_CA_element.pyx b/src/sage/rings/padics/padic_ZZ_pX_CA_element.pyx
    index 00d5adb1fa..6cba2a0328 100644
    a b from sage.rings.padics.precision_error import PrecisionError 
    183183from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX
    184184from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_small_Eis
    185185from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_big_Eis
     186from sage.misc.superseded import deprecated_function_alias, deprecation
    186187
    187188cdef object infinity
    188189from sage.rings.infinity import infinity
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    16841685        """
    16851686        return self._ntl_rep(), Integer(0)
    16861687
     1688    def polynomial(self, var='x'):
     1689        """
     1690        Returns a polynomial over the base ring that yields this element
     1691        when evaluated at the generator of the parent.
     1692
     1693        INPUT:
     1694
     1695        - ``var`` -- string, the variable name for the polynomial
     1696
     1697        EXAMPLES::
     1698
     1699            sage: S.<x> = ZZ[]
     1700            sage: W.<w> = ZpCA(5).extension(x^2 - 5)
     1701            sage: (w + W(5, 7)).polynomial()
     1702            (1 + O(5^3))*x + (5 + O(5^4))
     1703        """
     1704        R = self.base_ring()
     1705        S = R[var]
     1706        if self.absprec == 0:
     1707            return S([])
     1708        e = self.parent().e()
     1709        L = [Integer(c) for c in self._ntl_rep().list()]
     1710        if e == 1:
     1711            L = [R(c, self.absprec) for c in L]
     1712        else:
     1713            L = [R(c, (self.absprec - i - 1) // e + 1) for i, c in enumerate(L)]
     1714        return S(L)
     1715
    16871716    cdef ZZ_p_c _const_term(self):
    16881717        """
    16891718        Returns the constant term of ``self.value``.
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    17831812        ZZ_pX_conv_modulus(ans.value, self.value, self.prime_pow.get_context_capdiv(aprec).x)
    17841813        return ans
    17851814
    1786     def list(self, lift_mode = 'simple'):
     1815    def expansion(self, n = None, lift_mode = 'simple'):
    17871816        """
    17881817        Returns a list giving a series representation of ``self``.
    17891818
     1819        INPUT:
     1820
     1821        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     1822          entry in the expansion.
     1823
     1824        NOTES:
     1825
    17901826        - If ``lift_mode == 'simple'`` or ``'smallest'``, the returned
    17911827          list will consist of integers (in the eisenstein case) or a
    17921828          list of lists of integers (in the unramified case).
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    18141850            sage: W.<w> = R.ext(f)
    18151851            sage: y = W(775, 19); y
    18161852            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + O(w^19)
    1817             sage: (y>>9).list()
     1853            sage: (y>>9).expansion()
    18181854            [0, 1, 0, 4, 0, 2, 1, 2, 4, 1]
    1819             sage: (y>>9).list('smallest')
     1855            sage: (y>>9).expansion(lift_mode='smallest')
    18201856            [0, 1, 0, -1, 0, 2, 1, 2, 0, 1]
    18211857            sage: w^10 - w^12 + 2*w^14 + w^15 + 2*w^16 + w^18 + O(w^19)
    18221858            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + O(w^19)
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    18241860            sage: A.<a> = R.ext(g)
    18251861            sage: y = 75 + 45*a + 1200*a^2; y
    18261862            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
    1827             sage: y.list()
     1863            sage: y.expansion()
    18281864            [[], [0, 4], [3, 1, 3], [0, 0, 4], [0, 0, 1]]
    1829             sage: y.list('smallest')
     1865            sage: y.expansion(lift_mode='smallest')
    18301866            [[], [0, -1], [-2, 2, -2], [1], [0, 0, 2]]
    18311867            sage: 5*((-2*5 + 25) + (-1 + 2*5)*a + (-2*5 + 2*125)*a^2)
    18321868            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
    1833             sage: W(0).list()
    1834             [0]
    1835             sage: A(0,4).list()
     1869            sage: W(0).expansion()
     1870            []
     1871            sage: A(0,4).expansion()
    18361872            []
    18371873        """
     1874        if lift_mode == 'teichmuller':
     1875            zero = self.parent()(0)
     1876        elif self.prime_pow.e == 1:
     1877            zero = []
     1878        else:
     1879            zero = Integer(0)
     1880        if n in ('simple', 'smallest', 'teichmuller'):
     1881            deprecation(14825, "Interface to expansion has changed; first argument now n")
     1882            lift_mode = n
     1883            n = None
     1884        elif isinstance(n, slice):
     1885            return self.slice(n.start, n.stop, n.step)
     1886        elif n is not None:
     1887            if self.is_zero():
     1888                return zero
     1889            elif n >= self.absprec:
     1890                raise PrecisionError
     1891        if self.is_zero():
     1892            return []
    18381893        if lift_mode == 'simple':
    1839             ulist = self.ext_p_list(1)
     1894            ulist = self.ext_p_list(pos=True)
    18401895        elif lift_mode == 'smallest':
    1841             ulist = self.ext_p_list(0)
     1896            ulist = self.ext_p_list(pos=False)
    18421897        elif lift_mode == 'teichmuller':
    1843             ulist = self.teichmuller_list()
     1898            if n is None:
     1899                ulist = self.teichmuller_expansion()
     1900            else:
     1901                return self.teichmuller_expansion(n)
    18441902        else:
    18451903            raise ValueError("lift mode must be one of 'simple', 'smallest' or 'teichmuller'")
    18461904        ordp = self.valuation()
    1847         if self.is_zero():
    1848             ordp = 1
    1849         if lift_mode == 'teichmuller':
    1850             zero = self._new_c(0)
    1851             return [zero]*ordp + ulist
    1852         elif self.prime_pow.e == 1:
    1853             return [[]] * ordp + ulist
    1854         else:
    1855             return [Integer(0)] * ordp + ulist
     1905        if n is not None:
     1906            try:
     1907                return ulist[n - ordp]
     1908            except IndexError:
     1909                return zero
     1910        return [zero] * ordp + ulist
     1911
     1912    list = deprecated_function_alias(14825, expansion)
    18561913
    18571914    def matrix_mod_pn(self):
    18581915        """
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    19351992#         """
    19361993#         raise NotImplementedError
    19371994
    1938     def teichmuller_list(self):
     1995    def teichmuller_expansion(self, n = None):
    19391996        r"""
    19401997        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    19411998
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    19452002        - if `a_i \ne 0`, the absolute precision of `a_i` is
    19462003          ``self.precision_relative() - i``
    19472004
     2005        INPUT:
     2006
     2007        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     2008          entry in the expansion.
     2009
    19482010        EXAMPLES::
    19492011
    19502012            sage: R.<a> = Zq(5^4,4)
    1951             sage: L = a.teichmuller_list(); L
     2013            sage: L = a.teichmuller_expansion(); L
    19522014            [a + (2*a^3 + 2*a^2 + 3*a + 4)*5 + (4*a^3 + 3*a^2 + 3*a + 2)*5^2 + (4*a^2 + 2*a + 2)*5^3 + O(5^4), (3*a^3 + 3*a^2 + 2*a + 1) + (a^3 + 4*a^2 + 1)*5 + (a^2 + 4*a + 4)*5^2 + O(5^3), (4*a^3 + 2*a^2 + a + 1) + (2*a^3 + 2*a^2 + 2*a + 4)*5 + O(5^2), (a^3 + a^2 + a + 4) + O(5)]
    19532015            sage: sum([5^i*L[i] for i in range(4)])
    19542016            a + O(5^4)
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    19582020            sage: S.<x> = ZZ[]
    19592021            sage: f = x^3 - 98*x + 7
    19602022            sage: W.<w> = ZpCA(7,3).ext(f)
    1961             sage: b = (1+w)^5; L = b.teichmuller_list(); L
     2023            sage: b = (1+w)^5; L = b.teichmuller_expansion(); L
    19622024            [1 + O(w^9), 5 + 5*w^3 + w^6 + 4*w^7 + O(w^8), 3 + 3*w^3 + O(w^7), 3 + 3*w^3 + O(w^6), O(w^5), 4 + 5*w^3 + O(w^4), 3 + O(w^3), 6 + O(w^2), 6 + O(w)]
    19632025            sage: sum([w^i*L[i] for i in range(9)]) == b
    19642026            True
    19652027            sage: all([L[i]^(7^3) == L[i] for i in range(9)])
    19662028            True
    19672029
    1968             sage: L = W(3).teichmuller_list(); L
     2030            sage: L = W(3).teichmuller_expansion(); L
    19692031            [3 + 3*w^3 + w^7 + O(w^9), O(w^8), O(w^7), 4 + 5*w^3 + O(w^6), O(w^5), O(w^4), 3 + O(w^3), 6 + O(w^2)]
    19702032            sage: sum([w^i*L[i] for i in range(len(L))])
    19712033            3 + O(w^9)
    19722034        """
    1973         L = []
    1974         cdef long rp = self.absprec - self.valuation_c()
    1975         if rp == 0:
    1976             return L
     2035        cdef long ordp = self.valuation_c()
     2036        cdef long rp = self.absprec - ordp
     2037        cdef long goal
     2038        if n is not None: goal = self.absprec - n
     2039        cdef pAdicZZpXCAElement v
     2040        if n is None:
     2041            L = []
     2042            if rp == 0:
     2043                return L
     2044        elif n < ordp:
     2045            return self.parent()(0)
     2046        elif n >= self.absprec:
     2047            raise PrecisionError
     2048        else:
     2049            v = self._new_c(rp)
    19772050        cdef pAdicZZpXCAElement u = self.unit_part()
    19782051        if u is self: u = self.__copy__()
    1979         cdef pAdicZZpXCAElement v
    19802052        while not ZZ_pX_IsZero(u.value):
    19812053            v = self._new_c(rp)
    19822054            self.prime_pow.teichmuller_set_c(&v.value, &u.value, rp)
    1983             L.append(v)
     2055            if n is None:
     2056                L.append(v)
     2057            elif rp == goal:
     2058                return v
    19842059            if rp == 1: break
    19852060            ZZ_pX_sub(u.value, u.value, v.value)
    19862061            rp -= 1
    cdef class pAdicZZpXCAElement(pAdicZZpXElement): 
    19882063                ZZ_pX_right_pshift(u.value, u.value, self.prime_pow.pow_ZZ_tmp(1)[0], self.prime_pow.get_context(rp).x)
    19892064            else:
    19902065                self.prime_pow.eis_shift_capdiv(&u.value, &u.value, 1, rp)
    1991         return L
     2066        if n is None:
     2067            return L
     2068        else:
     2069            return self.parent()(0, rp)
    19922070
     2071    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
    19932072
    19942073    def _teichmuller_set_unsafe(self):
    19952074        """
  • src/sage/rings/padics/padic_ZZ_pX_CR_element.pyx

    diff --git a/src/sage/rings/padics/padic_ZZ_pX_CR_element.pyx b/src/sage/rings/padics/padic_ZZ_pX_CR_element.pyx
    index ba4bdd18a6..07735c5428 100644
    a b from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_small_Eis 
    208208from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_big_Eis
    209209from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
    210210from sage.rings.padics.unramified_extension_generic import UnramifiedExtensionGeneric
     211from sage.misc.superseded import deprecated_function_alias, deprecation
    211212
    212213from sage.rings.real_double cimport RealDoubleElement
    213214
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    25052506        ans.c = ctx
    25062507        return ans, ans_k
    25072508
     2509    def polynomial(self, var='x'):
     2510        """
     2511        Returns a polynomial over the base ring that yields this element
     2512        when evaluated at the generator of the parent.
     2513
     2514        INPUT:
     2515
     2516        - ``var`` -- string, the variable name for the polynomial
     2517
     2518        EXAMPLES::
     2519
     2520            sage: S.<x> = ZZ[]
     2521            sage: W.<w> = Zp(5).extension(x^2 - 5)
     2522            sage: (w + W(5, 7)).polynomial()
     2523            (1 + O(5^3))*x + (5 + O(5^4))
     2524        """
     2525        R = self.base_ring()
     2526        S = R[var]
     2527        if self.relprec == 0:
     2528            return S([])
     2529        prec = self.relprec + self.ordp
     2530        e = self.parent().e()
     2531        f, k = self._ntl_rep_abs()
     2532        L = [Integer(c) for c in f.list()]
     2533        if e == 1:
     2534            L = [R(c, prec) >> k for c in L]
     2535        else:
     2536            L = [R(c, (prec - i - 1) // e + 1) >> k for i, c in enumerate(L)]
     2537        return S(L)
     2538
    25082539    cdef ZZ_p_c _const_term(self):
    25092540        """
    25102541        Returns the constant term of ``self.unit``.
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    26372668        ZZ_pX_conv_modulus(ans.unit, self.unit, self.prime_pow.get_context_capdiv(rprec).x)
    26382669        return ans
    26392670
    2640     def list(self, lift_mode = 'simple'):
     2671    def expansion(self, n = None, lift_mode = 'simple'):
    26412672        """
    26422673        Returns a list giving a series representation of self.
    26432674
     2675        INPUT:
     2676
     2677        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     2678          entry in the expansion.
     2679
     2680        NOTES:
     2681
    26442682        - If ``lift_mode == 'simple'`` or ``'smallest'``, the returned
    26452683          list will consist of integers (in the Eisenstein case) or a
    26462684          list of lists of integers (in the unramified case).  ``self``
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    26722710            sage: W.<w> = R.ext(f)
    26732711            sage: y = W(775, 19); y
    26742712            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + O(w^19)
    2675             sage: (y>>9).list()
     2713            sage: (y>>9).expansion()
    26762714            [0, 1, 0, 4, 0, 2, 1, 2, 4, 1]
    2677             sage: (y>>9).list('smallest')
     2715            sage: (y>>9).expansion(lift_mode='smallest')
    26782716            [0, 1, 0, -1, 0, 2, 1, 2, 0, 1]
    26792717            sage: w^10 - w^12 + 2*w^14 + w^15 + 2*w^16 + w^18 + O(w^19)
    26802718            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + O(w^19)
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    26822720            sage: A.<a> = R.ext(g)
    26832721            sage: y = 75 + 45*a + 1200*a^2; y
    26842722            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^6)
    2685             sage: y.list()
     2723            sage: y.expansion()
    26862724            [[], [0, 4], [3, 1, 3], [0, 0, 4], [0, 0, 1]]
    2687             sage: y.list('smallest')
     2725            sage: y.expansion(lift_mode='smallest')
    26882726            [[], [0, -1], [-2, 2, -2], [1], [0, 0, 2]]
    26892727            sage: 5*((-2*5 + 25) + (-1 + 2*5)*a + (-2*5 + 2*125)*a^2)
    26902728            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^6)
    2691             sage: W(0).list()
     2729            sage: W(0).expansion()
     2730            []
     2731            sage: W(0,4).expansion()
    26922732            []
    2693             sage: W(0,4).list()
    2694             [0]
    2695             sage: A(0,4).list()
     2733            sage: A(0,4).expansion()
    26962734            []
    26972735        """
    2698         cdef pAdicZZpXCRElement zero
     2736        if lift_mode == 'teichmuller':
     2737            zero = self.parent()(0)
     2738        elif self.prime_pow.e == 1:
     2739            zero = []
     2740        else:
     2741            zero = Integer(0)
     2742        if n in ('simple', 'smallest', 'teichmuller'):
     2743            deprecation(14825, "Interface to expansion has changed; first argument now n")
     2744            lift_mode = n
     2745            n = None
     2746        elif isinstance(n, slice):
     2747            return self.slice(n.start, n.stop, n.step)
     2748        elif n is not None:
     2749            if self._is_exact_zero() or n < self.ordp:
     2750                return zero
     2751            elif n >= self.ordp + self.relprec:
     2752                raise PrecisionError
    26992753        cdef Integer ordp
    2700         if self._is_exact_zero():
     2754        if self.relprec == 0: # cannot have n = None
    27012755            return []
    2702         elif self._is_inexact_zero():
    2703             if lift_mode == 'teichmuller':
    2704                 zero = self._new_c(0)
    2705                 zero._set_inexact_zero(self.ordp)
    2706                 return [zero]
    2707             elif self.prime_pow.e == 1:
    2708                 return [[]]
    2709             else:
    2710                 return [Integer(0)]
    27112756        if lift_mode == 'simple':
    2712             ulist = self.ext_p_list(1)
     2757            ulist = self.ext_p_list(pos=True)
    27132758        elif lift_mode == 'smallest':
    2714             ulist = self.ext_p_list(0)
     2759            ulist = self.ext_p_list(pos=False)
    27152760        elif lift_mode == 'teichmuller':
    2716             ulist = self.teichmuller_list()
     2761            if n is None:
     2762                ulist = self.teichmuller_expansion()
     2763            else:
     2764                return self.teichmuller_expansion(n)
    27172765        else:
    27182766            raise ValueError("lift mode must be one of 'simple', 'smallest' or 'teichmuller'")
     2767        if n is not None:
     2768            try:
     2769                return ulist[n - self.ordp]
     2770            except IndexError:
     2771                return zero
    27192772        if self.prime_pow.in_field == 0 and self.ordp > 0:
    2720             ordp = PY_NEW(Integer)
    2721             mpz_set_si(ordp.value, self.ordp)
    2722             if lift_mode == 'teichmuller':
    2723                 zero = self._new_c(0)
    2724                 return [zero]*ordp + ulist
    2725             elif self.prime_pow.e == 1:
    2726                 return [[]] * ordp + ulist
    2727             else:
    2728                 return [Integer(0)] * ordp + ulist
    2729         else:
    2730             return ulist
     2773            ulist = [zero] * self.ordp + ulist
     2774        return ulist
     2775
     2776    list = deprecated_function_alias(14825, expansion)
    27312777
    27322778    def matrix_mod_pn(self):
    27332779        """
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    28302876#         """
    28312877#         raise NotImplementedError
    28322878
    2833     def teichmuller_list(self):
     2879    def teichmuller_expansion(self, n = None):
    28342880        r"""
    28352881        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    28362882
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    28402886        - if `a_i \ne 0`, the absolute precision of `a_i` is
    28412887          ``self.precision_relative() - i``
    28422888
     2889        INPUT:
     2890
     2891        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     2892          entry in the expansion.
     2893
    28432894        EXAMPLES::
    28442895
    28452896            sage: R.<a> = ZqCR(5^4,4)
    2846             sage: L = a.teichmuller_list(); L
     2897            sage: L = a.teichmuller_expansion(); L
    28472898            [a + (2*a^3 + 2*a^2 + 3*a + 4)*5 + (4*a^3 + 3*a^2 + 3*a + 2)*5^2 + (4*a^2 + 2*a + 2)*5^3 + O(5^4), (3*a^3 + 3*a^2 + 2*a + 1) + (a^3 + 4*a^2 + 1)*5 + (a^2 + 4*a + 4)*5^2 + O(5^3), (4*a^3 + 2*a^2 + a + 1) + (2*a^3 + 2*a^2 + 2*a + 4)*5 + O(5^2), (a^3 + a^2 + a + 4) + O(5)]
    28482899            sage: sum([5^i*L[i] for i in range(4)])
    28492900            a + O(5^4)
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    28532904            sage: S.<x> = ZZ[]
    28542905            sage: f = x^3 - 98*x + 7
    28552906            sage: W.<w> = ZpCR(7,3).ext(f)
    2856             sage: b = (1+w)^5; L = b.teichmuller_list(); L
     2907            sage: b = (1+w)^5; L = b.teichmuller_expansion(); L
    28572908            [1 + O(w^9), 5 + 5*w^3 + w^6 + 4*w^7 + O(w^8), 3 + 3*w^3 + O(w^7), 3 + 3*w^3 + O(w^6), O(w^5), 4 + 5*w^3 + O(w^4), 3 + O(w^3), 6 + O(w^2), 6 + O(w)]
    28582909            sage: sum([w^i*L[i] for i in range(9)]) == b
    28592910            True
    28602911            sage: all([L[i]^(7^3) == L[i] for i in range(9)])
    28612912            True
    28622913
    2863             sage: L = W(3).teichmuller_list(); L
     2914            sage: L = W(3).teichmuller_expansion(); L
    28642915            [3 + 3*w^3 + w^7 + O(w^9), O(w^8), O(w^7), 4 + 5*w^3 + O(w^6), O(w^5), O(w^4), 3 + O(w^3), 6 + O(w^2)]
    28652916            sage: sum([w^i*L[i] for i in range(len(L))])
    28662917            3 + O(w^9)
    28672918        """
    2868         L = []
    28692919        cdef long rp = self.relprec
    2870         if rp == 0:
    2871             return L
    2872         cdef pAdicZZpXCRElement u = self.unit_part()
    28732920        cdef pAdicZZpXCRElement v
     2921        if n is None:
     2922            L = []
     2923            if rp == 0:
     2924                return L
     2925        elif self._is_exact_zero() or n < self.ordp:
     2926            return self.parent()(0)
     2927        elif n >= self.ordp + rp:
     2928            raise PrecisionError
     2929        else:
     2930            v = self._new_c(rp)
     2931        cdef pAdicZZpXCRElement u = self.unit_part()
     2932        cdef long goal
     2933        if n is not None: goal = rp - n + self.ordp
    28742934        while u.relprec > 0:
    28752935            v = self._new_c(rp)
    28762936            self.prime_pow.teichmuller_set_c(&v.unit, &u.unit, rp)
    28772937            v.ordp = 0
    2878             L.append(v)
     2938            if n is None:
     2939                L.append(v)
     2940            elif rp == goal:
     2941                return v
    28792942            if rp == 1: break
    28802943            ZZ_pX_sub(u.unit, u.unit, v.unit)
    28812944            u.relprec = -u.relprec
    cdef class pAdicZZpXCRElement(pAdicZZpXElement): 
    28842947            rp -= 1
    28852948            u.ordp -= 1
    28862949            while u.ordp > 0:
    2887                 v = self._new_c(0)
    2888                 v._set_inexact_zero(rp)
    2889                 L.append(v)
     2950                if n is None:
     2951                    v = self._new_c(0)
     2952                    v._set_inexact_zero(rp)
     2953                    L.append(v)
     2954                elif rp == goal:
     2955                    v = self._new_c(0)
     2956                    v._set_inexact_zero(rp)
     2957                    return v
    28902958                rp -= 1
    28912959                u.ordp -= 1
    2892         return L
     2960        if n is None:
     2961            return L
     2962        else:
     2963            v = self._new_c(0)
     2964            v._set_inexact_zero(rp)
     2965            return v
     2966
     2967    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
    28932968
    28942969    def _teichmuller_set_unsafe(self):
    28952970        """
  • src/sage/rings/padics/padic_ZZ_pX_FM_element.pyx

    diff --git a/src/sage/rings/padics/padic_ZZ_pX_FM_element.pyx b/src/sage/rings/padics/padic_ZZ_pX_FM_element.pyx
    index 89c84c861c..2c652bdf2a 100644
    a b from sage.interfaces.gp import GpElement 
    144144from sage.rings.finite_rings.integer_mod import is_IntegerMod
    145145from sage.rings.all import IntegerModRing
    146146from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_FM_Eis
     147from sage.misc.superseded import deprecated_function_alias, deprecation
    147148
    148149cdef class pAdicZZpXFMElement(pAdicZZpXElement):
    149150    def __init__(self, parent, x, absprec=None, relprec=None, empty=False):
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    11331134        ans.x = self.value
    11341135        return ans
    11351136
     1137    def polynomial(self, var='x'):
     1138        """
     1139        Returns a polynomial over the base ring that yields this element
     1140        when evaluated at the generator of the parent.
     1141
     1142        INPUT:
     1143
     1144        - ``var`` -- string, the variable name for the polynomial
     1145
     1146        EXAMPLES::
     1147
     1148            sage: S.<x> = ZZ[]
     1149            sage: W.<w> = ZpFM(5).extension(x^2 - 5)
     1150            sage: (w + 5).polynomial()
     1151            (1 + O(5^20))*x + (5 + O(5^20))
     1152        """
     1153        R = self.base_ring()
     1154        S = R[var]
     1155        return S([Integer(c) for c in self._ntl_rep().list()])
     1156
    11361157    cdef ZZ_p_c _const_term(self):
    11371158        """
    11381159        Returns the constant term of ``self.unit``.
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    11981219        """
    11991220        return self
    12001221
    1201     def list(self, lift_mode = 'simple'):
     1222    def expansion(self, n = None, lift_mode = 'simple'):
    12021223        """
    12031224        Returns a list giving a series representation of ``self``.
    12041225
     1226        INPUT:
     1227
     1228        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     1229          entry in the expansion.
     1230
     1231        NOTES:
     1232
    12051233        - If ``lift_mode == 'simple' or 'smallest'``, the returned list will
    12061234          consist of
    12071235
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    12361264            sage: W.<w> = R.ext(f)
    12371265            sage: y = W(775); y
    12381266            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + w^20 + 2*w^21 + 3*w^22 + w^23 + w^24 + O(w^25)
    1239             sage: (y>>9).list()
     1267            sage: (y>>9).expansion()
    12401268            [0, 1, 0, 4, 0, 2, 1, 2, 4, 1, 0, 1, 2, 3, 1, 1, 4, 1, 2, 4, 1, 0, 0, 3]
    1241             sage: (y>>9).list('smallest')
     1269            sage: (y>>9).expansion(lift_mode='smallest')
    12421270            [0, 1, 0, -1, 0, 2, 1, 2, 0, 1, 2, 1, 1, -1, -1, 2, -2, 0, -2, -2, -2, 0, -2, -2, 2]
    12431271            sage: w^10 - w^12 + 2*w^14 + w^15 + 2*w^16 + w^18 + 2*w^19 + w^20 + w^21 - w^22 - w^23 + 2*w^24
    12441272            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + w^20 + 2*w^21 + 3*w^22 + w^23 + w^24 + O(w^25)
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    12461274            sage: A.<a> = R.ext(g)
    12471275            sage: y = 75 + 45*a + 1200*a^2; y
    12481276            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
    1249             sage: y.list()
     1277            sage: y.expansion()
    12501278            [[], [0, 4], [3, 1, 3], [0, 0, 4], [0, 0, 1]]
    1251             sage: y.list('smallest')
     1279            sage: y.expansion(lift_mode='smallest')
    12521280            [[], [0, -1], [-2, 2, -2], [1], [0, 0, 2]]
    12531281            sage: 5*((-2*5 + 25) + (-1 + 2*5)*a + (-2*5 + 2*125)*a^2)
    12541282            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
    1255             sage: W(0).list()
    1256             [0]
    1257             sage: A(0,4).list()
     1283            sage: W(0).expansion()
     1284            []
     1285            sage: A(0,4).expansion()
    12581286            []
    12591287        """
    1260         cdef pAdicZZpXFMElement zero
     1288        if lift_mode == 'teichmuller':
     1289            zero = self.parent()(0)
     1290        elif self.prime_pow.e == 1:
     1291            zero = []
     1292        else:
     1293            zero = Integer(0)
     1294        if n in ('simple', 'smallest', 'teichmuller'):
     1295            deprecation(14825, "Interface to expansion has changed; first argument now n")
     1296            lift_mode = n
     1297            n = None
     1298        elif isinstance(n, slice):
     1299            return self.slice(n.start, n.stop, n.step)
     1300        elif n is not None:
     1301            if self.is_zero() or n >= self.prime_pow.ram_prec_cap:
     1302                return zero
     1303        if self.is_zero():
     1304            return []
    12611305        if lift_mode == 'simple':
    1262             ulist = self.ext_p_list(1)
     1306            ulist = self.ext_p_list(pos=True)
    12631307        elif lift_mode == 'smallest':
    1264             ulist = self.ext_p_list(0)
     1308            ulist = self.ext_p_list(pos=False)
    12651309        elif lift_mode == 'teichmuller':
    1266             ulist = self.teichmuller_list()
     1310            if n is None:
     1311                ulist = self.teichmuller_list()
     1312            else:
     1313                return self.teichmuller_expansion(n)
    12671314        else:
    12681315            raise ValueError("lift mode must be one of 'simple', 'smallest' or 'teichmuller'")
    12691316        ordp = self.valuation()
    1270         if self.is_zero():
    1271             ordp = 1
    1272         if lift_mode == 'teichmuller':
    1273             zero = self._new_c()
    1274             return [zero]*ordp + ulist
    1275         elif self.prime_pow.e == 1:
    1276             return [[]] * ordp + ulist
    1277         else:
    1278             return [Integer(0)] * ordp + ulist
     1317        if n is not None:
     1318            try:
     1319                return ulist[n - ordp]
     1320            except IndexError:
     1321                return zero
     1322        return [zero] * ordp + ulist
    12791323
    1280     def teichmuller_list(self):
     1324    list = deprecated_function_alias(14825, expansion)
     1325
     1326    def teichmuller_expansion(self, n = None):
    12811327        r"""
    12821328        Returns a list [`a_0`, `a_1`,..., `a_n`] such that
    12831329
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    12851331        - ``self.unit_part()`` = `\sum_{i = 0}^n a_i \pi^i`, where `\pi` is a
    12861332          uniformizer of self.parent()
    12871333
     1334        INPUT:
     1335
     1336        - ``n`` -- integer (default ``None``).  If given, returns the corresponding
     1337          entry in the expansion.
     1338
    12881339        EXAMPLES::
    12891340
    12901341            sage: R.<a> = ZqFM(5^4,4)
    1291             sage: L = a.teichmuller_list(); L
     1342            sage: L = a.teichmuller_expansion(); L
    12921343            [a + (2*a^3 + 2*a^2 + 3*a + 4)*5 + (4*a^3 + 3*a^2 + 3*a + 2)*5^2 + (4*a^2 + 2*a + 2)*5^3 + O(5^4), (3*a^3 + 3*a^2 + 2*a + 1) + (a^3 + 4*a^2 + 1)*5 + (a^2 + 4*a + 4)*5^2 + (4*a^2 + a + 3)*5^3 + O(5^4), (4*a^3 + 2*a^2 + a + 1) + (2*a^3 + 2*a^2 + 2*a + 4)*5 + (3*a^3 + 2*a^2 + a + 1)*5^2 + (a^3 + a^2 + 2)*5^3 + O(5^4), (a^3 + a^2 + a + 4) + (3*a^3 + 1)*5 + (3*a^3 + a + 2)*5^2 + (3*a^3 + 3*a^2 + 3*a + 1)*5^3 + O(5^4)]
    12931344            sage: sum([5^i*L[i] for i in range(4)])
    12941345            a + O(5^4)
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    12981349            sage: S.<x> = ZZ[]
    12991350            sage: f = x^3 - 98*x + 7
    13001351            sage: W.<w> = ZpFM(7,3).ext(f)
    1301             sage: b = (1+w)^5; L = b.teichmuller_list(); L
     1352            sage: b = (1+w)^5; L = b.teichmuller_expansion(); L
    13021353            [1 + O(w^9), 5 + 5*w^3 + w^6 + 4*w^7 + O(w^9), 3 + 3*w^3 + w^7 + O(w^9), 3 + 3*w^3 + w^7 + O(w^9), O(w^9), 4 + 5*w^3 + w^6 + 4*w^7 + O(w^9), 3 + 3*w^3 + w^7 + O(w^9), 6 + w^3 + 5*w^7 + O(w^9), 6 + w^3 + 5*w^7 + O(w^9)]
    13031354            sage: sum([w^i*L[i] for i in range(len(L))]) == b
    13041355            True
    13051356            sage: all([L[i]^(7^3) == L[i] for i in range(9)])
    13061357            True
    13071358
    1308             sage: L = W(3).teichmuller_list(); L
     1359            sage: L = W(3).teichmuller_expansion(); L
    13091360            [3 + 3*w^3 + w^7 + O(w^9), O(w^9), O(w^9), 4 + 5*w^3 + w^6 + 4*w^7 + O(w^9), O(w^9), O(w^9), 3 + 3*w^3 + w^7 + O(w^9), 6 + w^3 + 5*w^7 + O(w^9)]
    13101361            sage: sum([w^i*L[i] for i in range(len(L))])
    13111362            3 + O(w^9)
    13121363        """
    1313         L = []
    1314         if ZZ_pX_IsZero(self.value):
    1315             return L
     1364        cdef long ordp = self.valuation_c()
     1365        cdef long rp = self.prime_pow.ram_prec_cap - ordp
     1366        cdef long goal
     1367        if n is not None: goal = self.ram_prec_cap - n
     1368        cdef pAdicZZpXFMElement v
     1369        if n is None:
     1370            L = []
     1371            if ZZ_pX_IsZero(self.value):
     1372                return L
     1373        elif n < ordp or n >= self.prime_pow.ram_prec_cap:
     1374            return self.parent()(0)
     1375        else:
     1376            v = self._new_c()
    13161377        cdef pAdicZZpXFMElement u = self.unit_part()
    13171378        if u is self: u = self.__copy__()
    1318         cdef pAdicZZpXFMElement v
    1319         cdef long rp = self.prime_pow.ram_prec_cap - self.valuation_c()
    13201379        while u.valuation_c() < rp:
    1321             v = self._new_c()
     1380            if n is None: v = self._new_c()
    13221381            self.prime_pow.teichmuller_set_c(&v.value, &u.value, self.prime_pow.ram_prec_cap)
    1323             L.append(v)
     1382            if n is None:
     1383                L.append(v)
     1384            elif rp == goal:
     1385                return v
    13241386            if rp == 1: break
    13251387            ZZ_pX_sub(u.value, u.value, v.value)
    13261388            rp -= 1
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    13281390                ZZ_pX_right_pshift(u.value, u.value, self.prime_pow.pow_ZZ_tmp(1)[0], self.prime_pow.get_top_context().x)
    13291391            else:
    13301392                self.prime_pow.eis_shift(&u.value, &u.value, 1, self.prime_pow.ram_prec_cap)
    1331         return L
     1393        if n is None:
     1394            return L
     1395        else:
     1396            return self.parent()(0)
     1397
     1398    teichmuller_list = deprecated_function_alias(14825, teichmuller_expansion)
    13321399
    13331400    def _teichmuller_set_unsafe(self):
    13341401        """
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    15461613            sage: W.<w> = R.ext(f)
    15471614            sage: y = W(775); y
    15481615            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + w^20 + 2*w^21 + 3*w^22 + w^23 + w^24 + O(w^25)
    1549             sage: (y>>9).list() #indirect doctest
     1616            sage: (y>>9).expansion() #indirect doctest
    15501617            [0, 1, 0, 4, 0, 2, 1, 2, 4, 1, 0, 1, 2, 3, 1, 1, 4, 1, 2, 4, 1, 0, 0, 3]
    1551             sage: (y>>9).list('smallest') #indirect doctest
     1618            sage: (y>>9).expansion(lift_mode='smallest') #indirect doctest
    15521619            [0, 1, 0, -1, 0, 2, 1, 2, 0, 1, 2, 1, 1, -1, -1, 2, -2, 0, -2, -2, -2, 0, -2, -2, 2]
    15531620            sage: w^10 - w^12 + 2*w^14 + w^15 + 2*w^16 + w^18 + 2*w^19 + w^20 + w^21 - w^22 - w^23 + 2*w^24
    15541621            w^10 + 4*w^12 + 2*w^14 + w^15 + 2*w^16 + 4*w^17 + w^18 + w^20 + 2*w^21 + 3*w^22 + w^23 + w^24 + O(w^25)
    cdef class pAdicZZpXFMElement(pAdicZZpXElement): 
    15561623            sage: A.<a> = R.ext(g)
    15571624            sage: y = 75 + 45*a + 1200*a^2; y
    15581625            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
    1559             sage: y.list() #indirect doctest
     1626            sage: y.expansion() #indirect doctest
    15601627            [[], [0, 4], [3, 1, 3], [0, 0, 4], [0, 0, 1]]
    1561             sage: y.list('smallest') #indirect doctest
     1628            sage: y.expansion(lift_mode='smallest') #indirect doctest
    15621629            [[], [0, -1], [-2, 2, -2], [1], [0, 0, 2]]
    15631630            sage: 5*((-2*5 + 25) + (-1 + 2*5)*a + (-2*5 + 2*125)*a^2)
    15641631            4*a*5 + (3*a^2 + a + 3)*5^2 + 4*a^2*5^3 + a^2*5^4 + O(5^5)
  • src/sage/rings/padics/padic_ext_element.pyx

    diff --git a/src/sage/rings/padics/padic_ext_element.pyx b/src/sage/rings/padics/padic_ext_element.pyx
    index fb08af1374..1043d0950d 100644
    a b cdef class pAdicExtElement(pAdicGenericElement): 
    370370        if R.e() != 1:
    371371            raise NotImplementedError("Frobenius automorphism only implemented for unramified extensions")
    372372        if self.is_zero(): return self
    373         L = self.teichmuller_list()
     373        L = self.teichmuller_expansion()
    374374        ppow = R.uniformizer_pow(self.valuation())
    375375        if arithmetic:
    376376            exp = R.prime()
    cdef class pAdicExtElement(pAdicGenericElement): 
    487487            from sage.rings.finite_rings.integer_mod import Mod
    488488            return Mod(0,1)
    489489        elif absprec == 1:
    490             return self.parent().residue_field()(self[0])
     490            return self.parent().residue_field()(self.expansion(0))
    491491        else:
    492492            raise NotImplementedError("residue() not implemented in extensions for absprec larger than one.")
  • src/sage/rings/padics/padic_generic_element.pyx

    diff --git a/src/sage/rings/padics/padic_generic_element.pyx b/src/sage/rings/padics/padic_generic_element.pyx
    index f6d5836461..dbdd1c51b8 100644
    a b cdef class pAdicGenericElement(LocalGenericElement): 
    298298            sage: R = Zp(7,4,'capped-rel','series'); a = R(1/3); a
    299299            5 + 4*7 + 4*7^2 + 4*7^3 + O(7^4)
    300300            sage: a[0] #indirect doctest
     301            doctest:warning
     302            ...
     303            DeprecationWarning: __getitem__ is changing to match the behavior of number fields. Please use expansion instead.
     304            See http://trac.sagemath.org/14825 for details.
    301305            5
    302306            sage: a[1]
    303307            4
    cdef class pAdicGenericElement(LocalGenericElement): 
    326330            sage: b[3]
    327331            Traceback (most recent call last):
    328332            ...
    329             IndexError: list index out of range
     333            PrecisionError
    330334            sage: b[-2]
    331335            0
    332336
    cdef class pAdicGenericElement(LocalGenericElement): 
    361365
    362366            :meth:`sage.rings.padics.local_generic_element.LocalGenericElement.slice`
    363367        """
    364         if isinstance(n, slice):
    365             return self.slice(n.start, n.stop, n.step)
    366         if self.parent().f() == 1:
    367             zero = Integer(0)
    368         else:
    369             zero = []
    370         if n < self.valuation():
    371             return zero
    372         if n >= self.precision_absolute():
    373             raise IndexError("list index out of range")
    374 
    375         if self.parent().is_field():
    376             n -= self.valuation()
    377 
    378         # trailing coefficients which are zero are not stored in self.list() -
    379         # we catch an IndexError to check for this.
    380         try:
    381             return self.list()[n]
    382         except IndexError:
    383             return zero
     368        from sage.misc.superseded import deprecation
     369        deprecation(14825, "__getitem__ is changing to match the behavior of number fields. Please use expansion instead.")
     370        return self.expansion(n)
    384371
    385372    def __invert__(self):
    386373        r"""
  • src/sage/rings/padics/padic_printing.pyx

    diff --git a/src/sage/rings/padics/padic_printing.pyx b/src/sage/rings/padics/padic_printing.pyx
    index cae22cab31..dbfaffdf1c 100644
    a b cdef class pAdicPrinter_class(SageObject): 
    810810            from sage.rings.padics.padic_capped_relative_element import base_p_list
    811811            return base_p_list(value, pos, self.prime_pow)
    812812        elif pos:
    813             return value.unit_part().list()
     813            return value.unit_part().expansion()
    814814        else:
    815             return value.unit_part().list('smallest')
     815            return value.unit_part().expansion(lift_mode='smallest')
    816816
    817817    def repr_gen(self, elt, do_latex, pos = None, mode = None, ram_name = None):
    818818        """
  • src/sage/rings/padics/padic_template_element.pxi

    diff --git a/src/sage/rings/padics/padic_template_element.pxi b/src/sage/rings/padics/padic_template_element.pxi
    index 7a27f59b27..cc6aa440f4 100644
    a b cdef class pAdicTemplateElement(pAdicGenericElement): 
    388388            zero = self.parent()(0,0)
    389389        else:
    390390            raise ValueError("%s not a recognized lift mode"%lift_mode)
    391         L = self.list(lift_mode)
     391        L = self.expansion(lift_mode=lift_mode)
    392392        if self.prime_pow.in_field == 1:
    393393            if self._is_exact_zero():
    394394                n = 0
    cdef class pAdicTemplateElement(pAdicGenericElement): 
    397397        return L[:n] + [zero] * (n - len(L))
    398398
    399399    def _ext_p_list(self, pos):
     400        """
     401        Returns the p-adic expansion of the unit part.  Used in printing.
     402
     403        EXAMPLES::
     404
     405            sage: R.<a> = Qq(125)
     406            sage: b = a^2 + 5*a + 1
     407            sage: b._ext_p_list(True)
     408            [[1, 0, 1], [0, 1]]
     409        """
    400410        if pos:
    401             return self.unit_part().list('simple')
     411            return self.unit_part().expansion(lift_mode='simple')
    402412        else:
    403             return self.unit_part().list('smallest')
     413            return self.unit_part().expansion(lift_mode='smallest')
    404414
    405415    cpdef pAdicTemplateElement unit_part(self):
    406416        """
  • src/sage/schemes/hyperelliptic_curves/hyperelliptic_padic_field.py

    diff --git a/src/sage/schemes/hyperelliptic_curves/hyperelliptic_padic_field.py b/src/sage/schemes/hyperelliptic_curves/hyperelliptic_padic_field.py
    index f9d30faae2..ee7cf30a70 100644
    a b class HyperellipticCurve_padic_field(hyperelliptic_generic.HyperellipticCurve_ge 
    278278            if xPv > 0:
    279279                return HF(0,0,1)
    280280            if xPv == 0:
    281                 return HF(P[0].list()[0], 0,1)
     281                return HF(P[0].expansion(0), 0,1)
    282282        elif yPv ==0:
    283283            if xPv > 0:
    284                 return HF(0, P[1].list()[0],1)
     284                return HF(0, P[1].expansion(0),1)
    285285            if xPv == 0:
    286                 return HF(P[0].list()[0], P[1].list()[0],1)
     286                return HF(P[0].expansion(0), P[1].expansion(0),1)
    287287        else:
    288288            return HF(0,1,0)
    289289
    class HyperellipticCurve_padic_field(hyperelliptic_generic.HyperellipticCurve_ge 
    599599                self = HyperellipticCurve(f).change_ring(K)
    600600                xP = P[0]
    601601                xPv = xP.valuation()
    602                 xPnew = K(sum(xP.list()[i]*p**(xPv + i) for i in range(len(xP.list()))))
     602                xPL = xP.expansion()
     603                xPnew = K(sum(xPL[i]*p**(xPv + i) for i in range(len(xPL))))
    603604                PP = P = self.lift_x(xPnew)
    604605                TP = self.frobenius(P)
    605606                xQ = Q[0]
    606607                xQv = xQ.valuation()
    607                 xQnew = K(sum(xQ.list()[i]*p**(xQv + i) for i in range(len(xQ.list()))))
     608                xQL = xQ.expansion()
     609                xQnew = K(sum(xQL[i]*p**(xQv + i) for i in range(len(xQL))))
    608610                QQ = Q = self.lift_x(xQnew)
    609611                TQ = self.frobenius(Q)
    610612                V = VectorSpace(K,dim)
    class HyperellipticCurve_padic_field(hyperelliptic_generic.HyperellipticCurve_ge 
    927929                except (TypeError, NotImplementedError):
    928930                    uN2 = 1 + h(x0)/y0**(2*p)
    929931                    #yfrob2 = f(x)
    930                     c = uN2.list()[0]
     932                    c = uN2.expansion(0)
    931933                    v = uN2.valuation()
    932934                    a = uN2.parent().gen()
    933935                    uN = self.newton_sqrt(uN2,c.sqrt()*a**(v//2),K.precision_cap())
    class HyperellipticCurve_padic_field(hyperelliptic_generic.HyperellipticCurve_ge 
    12301232        if S == FS:
    12311233            S_to_FS = V(dim*[0])
    12321234        else:
    1233             P = self(ZZ(FS[0][0]),ZZ(FS[1][0]))
     1235            P = self(ZZ(FS[0].expansion(0)),ZZ(FS[1].expansion(0)))
    12341236            x,y = self.local_coord(P,prec2)
    12351237            integrals = [(x**i*x.derivative()/(2*y)).integral() for i in range(dim)]
    12361238            S_to_FS = vector([I.polynomial()(FS[1]) - I.polynomial()(S[1]) for I in integrals])
    class HyperellipticCurve_padic_field(hyperelliptic_generic.HyperellipticCurve_ge 
    12461248        b = V(L)
    12471249        M_sys = matrix(K, M_frob).transpose() - 1
    12481250        B = (~M_sys)
    1249         v = [B.list()[i].valuation() for i in range(len(B.list()))]
     1251        BL = B.list()
     1252        v = [BL[i].valuation() for i in range(len(BL))]
    12501253        vv= min(v)
    12511254        B = (p**(-vv)*B).change_ring(K)
    12521255        B = p**(vv)*B