\(p\)-adic Capped Relative Elements

Elements of \(p\)-adic Rings with Capped Relative Precision

AUTHORS:

  • David Roe: initial version, rewriting to use templates (2012-3-1)

  • Genya Zaytman: documentation

  • David Harvey: doctests

class sage.rings.padics.padic_capped_relative_element.CRElement

Bases: pAdicTemplateElement

add_bigoh(absprec)

Return a new element with absolute precision decreased to absprec.

INPUT:

  • absprec – integer or infinity

OUTPUT:

an equal element with precision set to the minimum of self’s precision and absprec

EXAMPLES:

sage: R = Zp(7,4,'capped-rel','series'); a = R(8); a.add_bigoh(1)
1 + O(7)
sage: b = R(0); b.add_bigoh(3)
O(7^3)
sage: R = Qp(7,4); a = R(8); a.add_bigoh(1)
1 + O(7)
sage: b = R(0); b.add_bigoh(3)
O(7^3)
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(4),'capped-rel','series'); a = R(Integer(8)); a.add_bigoh(Integer(1))
1 + O(7)
>>> b = R(Integer(0)); b.add_bigoh(Integer(3))
O(7^3)
>>> R = Qp(Integer(7),Integer(4)); a = R(Integer(8)); a.add_bigoh(Integer(1))
1 + O(7)
>>> b = R(Integer(0)); b.add_bigoh(Integer(3))
O(7^3)

The precision never increases:

sage: R(4).add_bigoh(2).add_bigoh(4)
4 + O(7^2)
>>> from sage.all import *
>>> R(Integer(4)).add_bigoh(Integer(2)).add_bigoh(Integer(4))
4 + O(7^2)

Another example that illustrates that the precision does not increase:

sage: k = Qp(3,5)
sage: a = k(1234123412/3^70); a
2*3^-70 + 3^-69 + 3^-68 + 3^-67 + O(3^-65)
sage: a.add_bigoh(2)
2*3^-70 + 3^-69 + 3^-68 + 3^-67 + O(3^-65)

sage: k = Qp(5,10)
sage: a = k(1/5^3 + 5^2); a
5^-3 + 5^2 + O(5^7)
sage: a.add_bigoh(2)
5^-3 + O(5^2)
sage: a.add_bigoh(-1)
5^-3 + O(5^-1)
>>> from sage.all import *
>>> k = Qp(Integer(3),Integer(5))
>>> a = k(Integer(1234123412)/Integer(3)**Integer(70)); a
2*3^-70 + 3^-69 + 3^-68 + 3^-67 + O(3^-65)
>>> a.add_bigoh(Integer(2))
2*3^-70 + 3^-69 + 3^-68 + 3^-67 + O(3^-65)

>>> k = Qp(Integer(5),Integer(10))
>>> a = k(Integer(1)/Integer(5)**Integer(3) + Integer(5)**Integer(2)); a
5^-3 + 5^2 + O(5^7)
>>> a.add_bigoh(Integer(2))
5^-3 + O(5^2)
>>> a.add_bigoh(-Integer(1))
5^-3 + O(5^-1)
is_equal_to(_right, absprec=None)

Return whether self is equal to right modulo \(\pi^{\mbox{absprec}}\).

If absprec is None, returns True if self and right are equal to the minimum of their precisions.

INPUT:

  • right – a \(p\)-adic element

  • absprec – integer, infinity, or None

EXAMPLES:

sage: R = Zp(5, 10); a = R(0); b = R(0, 3); c = R(75, 5)
sage: aa = a + 625; bb = b + 625; cc = c + 625
sage: a.is_equal_to(aa), a.is_equal_to(aa, 4), a.is_equal_to(aa, 5)
(False, True, False)
sage: a.is_equal_to(aa, 15)
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

sage: a.is_equal_to(a, 50000)
True

sage: a.is_equal_to(b), a.is_equal_to(b, 2)
(True, True)
sage: a.is_equal_to(b, 5)
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

sage: b.is_equal_to(b, 5)
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

sage: b.is_equal_to(bb, 3)
True
sage: b.is_equal_to(bb, 4)
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

sage: c.is_equal_to(b, 2), c.is_equal_to(b, 3)
(True, False)
sage: c.is_equal_to(b, 4)
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

sage: c.is_equal_to(cc, 2), c.is_equal_to(cc, 4), c.is_equal_to(cc, 5)
(True, True, False)
>>> from sage.all import *
>>> R = Zp(Integer(5), Integer(10)); a = R(Integer(0)); b = R(Integer(0), Integer(3)); c = R(Integer(75), Integer(5))
>>> aa = a + Integer(625); bb = b + Integer(625); cc = c + Integer(625)
>>> a.is_equal_to(aa), a.is_equal_to(aa, Integer(4)), a.is_equal_to(aa, Integer(5))
(False, True, False)
>>> a.is_equal_to(aa, Integer(15))
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

>>> a.is_equal_to(a, Integer(50000))
True

>>> a.is_equal_to(b), a.is_equal_to(b, Integer(2))
(True, True)
>>> a.is_equal_to(b, Integer(5))
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

>>> b.is_equal_to(b, Integer(5))
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

>>> b.is_equal_to(bb, Integer(3))
True
>>> b.is_equal_to(bb, Integer(4))
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

>>> c.is_equal_to(b, Integer(2)), c.is_equal_to(b, Integer(3))
(True, False)
>>> c.is_equal_to(b, Integer(4))
Traceback (most recent call last):
...
PrecisionError: elements not known to enough precision

>>> c.is_equal_to(cc, Integer(2)), c.is_equal_to(cc, Integer(4)), c.is_equal_to(cc, Integer(5))
(True, True, False)
is_zero(absprec=None)

Determine whether this element is zero modulo \(\pi^{\mbox{absprec}}\).

If absprec is None, returns True if this element is indistinguishable from zero.

INPUT:

  • absprec – integer, infinity, or None

EXAMPLES:

sage: R = Zp(5); a = R(0); b = R(0,5); c = R(75)
sage: a.is_zero(), a.is_zero(6)
(True, True)
sage: b.is_zero(), b.is_zero(5)
(True, True)
sage: c.is_zero(), c.is_zero(2), c.is_zero(3)
(False, True, False)
sage: b.is_zero(6)
Traceback (most recent call last):
...
PrecisionError: not enough precision to determine if element is zero
>>> from sage.all import *
>>> R = Zp(Integer(5)); a = R(Integer(0)); b = R(Integer(0),Integer(5)); c = R(Integer(75))
>>> a.is_zero(), a.is_zero(Integer(6))
(True, True)
>>> b.is_zero(), b.is_zero(Integer(5))
(True, True)
>>> c.is_zero(), c.is_zero(Integer(2)), c.is_zero(Integer(3))
(False, True, False)
>>> b.is_zero(Integer(6))
Traceback (most recent call last):
...
PrecisionError: not enough precision to determine if element is zero
polynomial(var='x')

Return a polynomial over the base ring that yields this element when evaluated at the generator of the parent.

INPUT:

  • var – string, the variable name for the polynomial

EXAMPLES:

sage: # needs sage.libs.ntl
sage: K.<a> = Qq(5^3)
sage: a.polynomial()
(1 + O(5^20))*x + O(5^20)
sage: a.polynomial(var='y')
(1 + O(5^20))*y + O(5^20)
sage: (5*a^2 + K(25, 4)).polynomial()
(5 + O(5^4))*x^2 + O(5^4)*x + 5^2 + O(5^4)
>>> from sage.all import *
>>> # needs sage.libs.ntl
>>> K = Qq(Integer(5)**Integer(3), names=('a',)); (a,) = K._first_ngens(1)
>>> a.polynomial()
(1 + O(5^20))*x + O(5^20)
>>> a.polynomial(var='y')
(1 + O(5^20))*y + O(5^20)
>>> (Integer(5)*a**Integer(2) + K(Integer(25), Integer(4))).polynomial()
(5 + O(5^4))*x^2 + O(5^4)*x + 5^2 + O(5^4)
precision_absolute()

Return the absolute precision of this element.

This is the power of the maximal ideal modulo which this element is defined.

EXAMPLES:

sage: R = Zp(7,3,'capped-rel'); a = R(7); a.precision_absolute()
4
sage: R = Qp(7,3); a = R(7); a.precision_absolute()
4
sage: R(7^-3).precision_absolute()
0

sage: R(0).precision_absolute()
+Infinity
sage: R(0,7).precision_absolute()
7
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(3),'capped-rel'); a = R(Integer(7)); a.precision_absolute()
4
>>> R = Qp(Integer(7),Integer(3)); a = R(Integer(7)); a.precision_absolute()
4
>>> R(Integer(7)**-Integer(3)).precision_absolute()
0

>>> R(Integer(0)).precision_absolute()
+Infinity
>>> R(Integer(0),Integer(7)).precision_absolute()
7
precision_relative()

Return the relative precision of this element.

This is the power of the maximal ideal modulo which the unit part of self is defined.

EXAMPLES:

sage: R = Zp(7,3,'capped-rel'); a = R(7); a.precision_relative()
3
sage: R = Qp(7,3); a = R(7); a.precision_relative()
3
sage: a = R(7^-2, -1); a.precision_relative()
1
sage: a
7^-2 + O(7^-1)

sage: R(0).precision_relative()
0
sage: R(0,7).precision_relative()
0
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(3),'capped-rel'); a = R(Integer(7)); a.precision_relative()
3
>>> R = Qp(Integer(7),Integer(3)); a = R(Integer(7)); a.precision_relative()
3
>>> a = R(Integer(7)**-Integer(2), -Integer(1)); a.precision_relative()
1
>>> a
7^-2 + O(7^-1)

>>> R(Integer(0)).precision_relative()
0
>>> R(Integer(0),Integer(7)).precision_relative()
0
unit_part()

Return \(u\), where this element is \(\pi^v u\).

EXAMPLES:

sage: R = Zp(17,4,'capped-rel')
sage: a = R(18*17)
sage: a.unit_part()
1 + 17 + O(17^4)
sage: type(a)
<class 'sage.rings.padics.padic_capped_relative_element.pAdicCappedRelativeElement'>
sage: R = Qp(17,4,'capped-rel')
sage: a = R(18*17)
sage: a.unit_part()
1 + 17 + O(17^4)
sage: type(a)
<class 'sage.rings.padics.padic_capped_relative_element.pAdicCappedRelativeElement'>
sage: a = R(2*17^2); a
2*17^2 + O(17^6)
sage: a.unit_part()
2 + O(17^4)
sage: b=1/a; b
9*17^-2 + 8*17^-1 + 8 + 8*17 + O(17^2)
sage: b.unit_part()
9 + 8*17 + 8*17^2 + 8*17^3 + O(17^4)
sage: Zp(5)(75).unit_part()
3 + O(5^20)

sage: R(0).unit_part()
Traceback (most recent call last):
...
ValueError: unit part of 0 not defined
sage: R(0,7).unit_part()
O(17^0)
>>> from sage.all import *
>>> R = Zp(Integer(17),Integer(4),'capped-rel')
>>> a = R(Integer(18)*Integer(17))
>>> a.unit_part()
1 + 17 + O(17^4)
>>> type(a)
<class 'sage.rings.padics.padic_capped_relative_element.pAdicCappedRelativeElement'>
>>> R = Qp(Integer(17),Integer(4),'capped-rel')
>>> a = R(Integer(18)*Integer(17))
>>> a.unit_part()
1 + 17 + O(17^4)
>>> type(a)
<class 'sage.rings.padics.padic_capped_relative_element.pAdicCappedRelativeElement'>
>>> a = R(Integer(2)*Integer(17)**Integer(2)); a
2*17^2 + O(17^6)
>>> a.unit_part()
2 + O(17^4)
>>> b=Integer(1)/a; b
9*17^-2 + 8*17^-1 + 8 + 8*17 + O(17^2)
>>> b.unit_part()
9 + 8*17 + 8*17^2 + 8*17^3 + O(17^4)
>>> Zp(Integer(5))(Integer(75)).unit_part()
3 + O(5^20)

>>> R(Integer(0)).unit_part()
Traceback (most recent call last):
...
ValueError: unit part of 0 not defined
>>> R(Integer(0),Integer(7)).unit_part()
O(17^0)
val_unit(p=None)

Return a pair (self.valuation(), self.unit_part()).

INPUT:

  • p – a prime (default: None); if specified, will make sure that p == self.parent().prime()

Note

The optional argument p is used for consistency with the valuation methods on integers and rationals.

EXAMPLES:

sage: R = Zp(5); a = R(75, 20); a
3*5^2 + O(5^20)
sage: a.val_unit()
(2, 3 + O(5^18))
sage: R(0).val_unit()
Traceback (most recent call last):
...
ValueError: unit part of 0 not defined
sage: R(0, 10).val_unit()
(10, O(5^0))
>>> from sage.all import *
>>> R = Zp(Integer(5)); a = R(Integer(75), Integer(20)); a
3*5^2 + O(5^20)
>>> a.val_unit()
(2, 3 + O(5^18))
>>> R(Integer(0)).val_unit()
Traceback (most recent call last):
...
ValueError: unit part of 0 not defined
>>> R(Integer(0), Integer(10)).val_unit()
(10, O(5^0))
class sage.rings.padics.padic_capped_relative_element.ExpansionIter

Bases: object

An iterator over a \(p\)-adic expansion.

This class should not be instantiated directly, but instead using expansion().

INPUT:

  • elt – the \(p\)-adic element

  • prec – the number of terms to be emitted

  • mode – either simple_mode, smallest_mode or teichmuller_mode

EXAMPLES:

sage: E = Zp(5,4)(373).expansion()
sage: I = iter(E)  # indirect doctest
sage: type(I)
<class 'sage.rings.padics.padic_capped_relative_element.ExpansionIter'>
>>> from sage.all import *
>>> E = Zp(Integer(5),Integer(4))(Integer(373)).expansion()
>>> I = iter(E)  # indirect doctest
>>> type(I)
<class 'sage.rings.padics.padic_capped_relative_element.ExpansionIter'>
class sage.rings.padics.padic_capped_relative_element.ExpansionIterable

Bases: object

An iterable storing a \(p\)-adic expansion of an element.

This class should not be instantiated directly, but instead using expansion().

INPUT:

  • elt – the \(p\)-adic element

  • prec – the number of terms to be emitted

  • val_shift – how many zeros to add at the beginning of the expansion, or the number of initial terms to truncate (if negative)

  • mode – one of the following:

    • 'simple_mode'

    • 'smallest_mode'

    • 'teichmuller_mode'

EXAMPLES:

sage: E = Zp(5,4)(373).expansion()  # indirect doctest
sage: type(E)
<class 'sage.rings.padics.padic_capped_relative_element.ExpansionIterable'>
>>> from sage.all import *
>>> E = Zp(Integer(5),Integer(4))(Integer(373)).expansion()  # indirect doctest
>>> type(E)
<class 'sage.rings.padics.padic_capped_relative_element.ExpansionIterable'>
class sage.rings.padics.padic_capped_relative_element.PowComputer_

Bases: PowComputer_base

A PowComputer for a capped-relative \(p\)-adic ring or field.

sage.rings.padics.padic_capped_relative_element.base_p_list(n, pos, prime_pow)

Return a base-\(p\) list of digits of n.

INPUT:

  • n – a positive Integer

  • pos – boolean; if True, then returns the standard base \(p\) expansion, otherwise the digits lie in the range \(-p/2\) to \(p/2\)

  • prime_pow – a PowComputer giving the prime

EXAMPLES:

sage: from sage.rings.padics.padic_capped_relative_element import base_p_list
sage: base_p_list(192837, True, Zp(5).prime_pow)
[2, 2, 3, 2, 3, 1, 2, 2]
sage: 2 + 2*5 + 3*5^2 + 2*5^3 + 3*5^4 + 5^5 + 2*5^6 + 2*5^7
192837
sage: base_p_list(192837, False, Zp(5).prime_pow)
[2, 2, -2, -2, -1, 2, 2, 2]
sage: 2 + 2*5 - 2*5^2 - 2*5^3 - 5^4 + 2*5^5 + 2*5^6 + 2*5^7
192837
>>> from sage.all import *
>>> from sage.rings.padics.padic_capped_relative_element import base_p_list
>>> base_p_list(Integer(192837), True, Zp(Integer(5)).prime_pow)
[2, 2, 3, 2, 3, 1, 2, 2]
>>> Integer(2) + Integer(2)*Integer(5) + Integer(3)*Integer(5)**Integer(2) + Integer(2)*Integer(5)**Integer(3) + Integer(3)*Integer(5)**Integer(4) + Integer(5)**Integer(5) + Integer(2)*Integer(5)**Integer(6) + Integer(2)*Integer(5)**Integer(7)
192837
>>> base_p_list(Integer(192837), False, Zp(Integer(5)).prime_pow)
[2, 2, -2, -2, -1, 2, 2, 2]
>>> Integer(2) + Integer(2)*Integer(5) - Integer(2)*Integer(5)**Integer(2) - Integer(2)*Integer(5)**Integer(3) - Integer(5)**Integer(4) + Integer(2)*Integer(5)**Integer(5) + Integer(2)*Integer(5)**Integer(6) + Integer(2)*Integer(5)**Integer(7)
192837
class sage.rings.padics.padic_capped_relative_element.pAdicCappedRelativeElement

Bases: CRElement

Construct new element with given parent and value.

INPUT:

  • x – value to coerce into a capped relative ring or field

  • absprec – maximum number of digits of absolute precision

  • relprec – maximum number of digits of relative precision

EXAMPLES:

sage: R = Zp(5, 10, 'capped-rel')
>>> from sage.all import *
>>> R = Zp(Integer(5), Integer(10), 'capped-rel')

Construct from integers:

sage: R(3)
3 + O(5^10)
sage: R(75)
3*5^2 + O(5^12)
sage: R(0)
0
sage: R(-1)
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + O(5^10)
sage: R(-5)
4*5 + 4*5^2 + 4*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + 4*5^10 + O(5^11)
sage: R(-7*25)
3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + 4*5^10 + 4*5^11 + O(5^12)
>>> from sage.all import *
>>> R(Integer(3))
3 + O(5^10)
>>> R(Integer(75))
3*5^2 + O(5^12)
>>> R(Integer(0))
0
>>> R(-Integer(1))
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + O(5^10)
>>> R(-Integer(5))
4*5 + 4*5^2 + 4*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + 4*5^10 + O(5^11)
>>> R(-Integer(7)*Integer(25))
3*5^2 + 3*5^3 + 4*5^4 + 4*5^5 + 4*5^6 + 4*5^7 + 4*5^8 + 4*5^9 + 4*5^10 + 4*5^11 + O(5^12)

Construct from rationals:

sage: R(1/2)
3 + 2*5 + 2*5^2 + 2*5^3 + 2*5^4 + 2*5^5 + 2*5^6 + 2*5^7 + 2*5^8 + 2*5^9 + O(5^10)
sage: R(-7875/874)
3*5^3 + 2*5^4 + 2*5^5 + 5^6 + 3*5^7 + 2*5^8 + 3*5^10 + 3*5^11 + 3*5^12 + O(5^13)
sage: R(15/425)
Traceback (most recent call last):
...
ValueError: p divides the denominator
>>> from sage.all import *
>>> R(Integer(1)/Integer(2))
3 + 2*5 + 2*5^2 + 2*5^3 + 2*5^4 + 2*5^5 + 2*5^6 + 2*5^7 + 2*5^8 + 2*5^9 + O(5^10)
>>> R(-Integer(7875)/Integer(874))
3*5^3 + 2*5^4 + 2*5^5 + 5^6 + 3*5^7 + 2*5^8 + 3*5^10 + 3*5^11 + 3*5^12 + O(5^13)
>>> R(Integer(15)/Integer(425))
Traceback (most recent call last):
...
ValueError: p divides the denominator

Construct from IntegerMod:

sage: R(Integers(125)(3))
3 + O(5^3)
sage: R(Integers(5)(3))
3 + O(5)
sage: R(Integers(5^30)(3))
3 + O(5^10)
sage: R(Integers(5^30)(1+5^23))
1 + O(5^10)
sage: R(Integers(49)(3))
Traceback (most recent call last):
...
TypeError: p does not divide modulus 49
>>> from sage.all import *
>>> R(Integers(Integer(125))(Integer(3)))
3 + O(5^3)
>>> R(Integers(Integer(5))(Integer(3)))
3 + O(5)
>>> R(Integers(Integer(5)**Integer(30))(Integer(3)))
3 + O(5^10)
>>> R(Integers(Integer(5)**Integer(30))(Integer(1)+Integer(5)**Integer(23)))
1 + O(5^10)
>>> R(Integers(Integer(49))(Integer(3)))
Traceback (most recent call last):
...
TypeError: p does not divide modulus 49

sage: R(Integers(48)(3))
Traceback (most recent call last):
...
TypeError: p does not divide modulus 48
>>> from sage.all import *
>>> R(Integers(Integer(48))(Integer(3)))
Traceback (most recent call last):
...
TypeError: p does not divide modulus 48

Some other conversions:

sage: R(R(5))
5 + O(5^11)
>>> from sage.all import *
>>> R(R(Integer(5)))
5 + O(5^11)

Construct from Pari objects:

sage: R = Zp(5)
sage: x = pari(123123) ; R(x)                                                   # needs sage.libs.pari
3 + 4*5 + 4*5^2 + 4*5^3 + 5^4 + 4*5^5 + 2*5^6 + 5^7 + O(5^20)
sage: R(pari(R(5252)))
2 + 2*5^3 + 3*5^4 + 5^5 + O(5^20)
sage: R = Zp(5,prec=5)
sage: R(pari(-1))
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5)
sage: pari(R(-1))                                                               # needs sage.libs.pari
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5)
sage: pari(R(0))                                                                # needs sage.libs.pari
0
sage: R(pari(R(0,5)))
O(5^5)
>>> from sage.all import *
>>> R = Zp(Integer(5))
>>> x = pari(Integer(123123)) ; R(x)                                                   # needs sage.libs.pari
3 + 4*5 + 4*5^2 + 4*5^3 + 5^4 + 4*5^5 + 2*5^6 + 5^7 + O(5^20)
>>> R(pari(R(Integer(5252))))
2 + 2*5^3 + 3*5^4 + 5^5 + O(5^20)
>>> R = Zp(Integer(5),prec=Integer(5))
>>> R(pari(-Integer(1)))
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5)
>>> pari(R(-Integer(1)))                                                               # needs sage.libs.pari
4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5)
>>> pari(R(Integer(0)))                                                                # needs sage.libs.pari
0
>>> R(pari(R(Integer(0),Integer(5))))
O(5^5)

Todo

doctests for converting from other types of \(p\)-adic rings

lift()

Return an integer or rational congruent to self modulo self’s precision. If a rational is returned, its denominator will equal p^ordp(self).

EXAMPLES:

sage: R = Zp(7,4,'capped-rel'); a = R(8); a.lift()
8
sage: R = Qp(7,4); a = R(8); a.lift()
8
sage: R = Qp(7,4); a = R(8/7); a.lift()
8/7
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(4),'capped-rel'); a = R(Integer(8)); a.lift()
8
>>> R = Qp(Integer(7),Integer(4)); a = R(Integer(8)); a.lift()
8
>>> R = Qp(Integer(7),Integer(4)); a = R(Integer(8)/Integer(7)); a.lift()
8/7
residue(absprec=1, field=None, check_prec=True)

Reduce this element modulo \(p^{\mathrm{absprec}}\).

INPUT:

  • absprec – nonnegative integer (default: 1)

  • field – boolean (default: None); whether to return an element of \(\GF{p}\) or \(\ZZ / p\ZZ\)

  • check_prec – boolean (default: True); whether to raise an error if this element has insufficient precision to determine the reduction

OUTPUT:

This element reduced modulo \(p^\mathrm{absprec}\) as an element of \(\ZZ/p^\mathrm{absprec}\ZZ\).

EXAMPLES:

sage: R = Zp(7,4)
sage: a = R(8)
sage: a.residue(1)
1
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(4))
>>> a = R(Integer(8))
>>> a.residue(Integer(1))
1

This is different from applying % p^n which returns an element in the same ring:

sage: b = a.residue(2); b
8
sage: b.parent()
Ring of integers modulo 49
sage: c = a % 7^2; c
1 + 7 + O(7^4)
sage: c.parent()
7-adic Ring with capped relative precision 4
>>> from sage.all import *
>>> b = a.residue(Integer(2)); b
8
>>> b.parent()
Ring of integers modulo 49
>>> c = a % Integer(7)**Integer(2); c
1 + 7 + O(7^4)
>>> c.parent()
7-adic Ring with capped relative precision 4

For elements in a field, application of % p^n always returns zero, the remainder of the division by p^n:

sage: K = Qp(7,4)
sage: a = K(8)
sage: a.residue(2)
8
sage: a % 7^2
1 + 7 + O(7^4)

sage: b = K(1/7)
sage: b.residue()
Traceback (most recent call last):
...
ValueError: element must have nonnegative valuation in order to compute residue
>>> from sage.all import *
>>> K = Qp(Integer(7),Integer(4))
>>> a = K(Integer(8))
>>> a.residue(Integer(2))
8
>>> a % Integer(7)**Integer(2)
1 + 7 + O(7^4)

>>> b = K(Integer(1)/Integer(7))
>>> b.residue()
Traceback (most recent call last):
...
ValueError: element must have nonnegative valuation in order to compute residue

See also

_mod_()

class sage.rings.padics.padic_capped_relative_element.pAdicCoercion_CR_frac_field

Bases: RingHomomorphism

The canonical inclusion of \(\ZZ_q\) into its fraction field.

EXAMPLES:

sage: # needs sage.libs.flint
sage: R.<a> = ZqCR(27, implementation='FLINT')
sage: K = R.fraction_field()
sage: f = K.coerce_map_from(R); f
Ring morphism:
  From: 3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
>>> from sage.all import *
>>> # needs sage.libs.flint
>>> R = ZqCR(Integer(27), implementation='FLINT', names=('a',)); (a,) = R._first_ngens(1)
>>> K = R.fraction_field()
>>> f = K.coerce_map_from(R); f
Ring morphism:
  From: 3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
is_injective()

Return whether this map is injective.

EXAMPLES:

sage: # needs sage.libs.flint
sage: R.<a> = ZqCR(9, implementation='FLINT')
sage: K = R.fraction_field()
sage: f = K.coerce_map_from(R)
sage: f.is_injective()
True
>>> from sage.all import *
>>> # needs sage.libs.flint
>>> R = ZqCR(Integer(9), implementation='FLINT', names=('a',)); (a,) = R._first_ngens(1)
>>> K = R.fraction_field()
>>> f = K.coerce_map_from(R)
>>> f.is_injective()
True
is_surjective()

Return whether this map is surjective.

EXAMPLES:

sage: # needs sage.libs.flint
sage: R.<a> = ZqCR(9, implementation='FLINT')
sage: K = R.fraction_field()
sage: f = K.coerce_map_from(R)
sage: f.is_surjective()
False
>>> from sage.all import *
>>> # needs sage.libs.flint
>>> R = ZqCR(Integer(9), implementation='FLINT', names=('a',)); (a,) = R._first_ngens(1)
>>> K = R.fraction_field()
>>> f = K.coerce_map_from(R)
>>> f.is_surjective()
False
section()

Return a map back to the ring that converts elements of nonnegative valuation.

EXAMPLES:

sage: # needs sage.libs.flint
sage: R.<a> = ZqCR(27, implementation='FLINT')
sage: K = R.fraction_field()
sage: f = K.coerce_map_from(R)
sage: f(K.gen())
a + O(3^20)
sage: f.section()
Generic morphism:
  From: 3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
>>> from sage.all import *
>>> # needs sage.libs.flint
>>> R = ZqCR(Integer(27), implementation='FLINT', names=('a',)); (a,) = R._first_ngens(1)
>>> K = R.fraction_field()
>>> f = K.coerce_map_from(R)
>>> f(K.gen())
a + O(3^20)
>>> f.section()
Generic morphism:
  From: 3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
class sage.rings.padics.padic_capped_relative_element.pAdicCoercion_QQ_CR

Bases: RingHomomorphism

The canonical inclusion from the rationals to a capped relative field.

EXAMPLES:

sage: f = Qp(5).coerce_map_from(QQ); f
Ring morphism:
  From: Rational Field
  To:   5-adic Field with capped relative precision 20
>>> from sage.all import *
>>> f = Qp(Integer(5)).coerce_map_from(QQ); f
Ring morphism:
  From: Rational Field
  To:   5-adic Field with capped relative precision 20
section()

Return a map back to the rationals that approximates an element by a rational number.

EXAMPLES:

sage: f = Qp(5).coerce_map_from(QQ).section()
sage: f(Qp(5)(1/4))
1/4
sage: f(Qp(5)(1/5))
1/5
>>> from sage.all import *
>>> f = Qp(Integer(5)).coerce_map_from(QQ).section()
>>> f(Qp(Integer(5))(Integer(1)/Integer(4)))
1/4
>>> f(Qp(Integer(5))(Integer(1)/Integer(5)))
1/5
class sage.rings.padics.padic_capped_relative_element.pAdicCoercion_ZZ_CR

Bases: RingHomomorphism

The canonical inclusion from the integer ring to a capped relative ring.

EXAMPLES:

sage: f = Zp(5).coerce_map_from(ZZ); f
Ring morphism:
  From: Integer Ring
  To:   5-adic Ring with capped relative precision 20
>>> from sage.all import *
>>> f = Zp(Integer(5)).coerce_map_from(ZZ); f
Ring morphism:
  From: Integer Ring
  To:   5-adic Ring with capped relative precision 20
section()

Return a map back to the ring of integers that approximates an element by an integer.

EXAMPLES:

sage: f = Zp(5).coerce_map_from(ZZ).section()
sage: f(Zp(5)(-1)) - 5^20
-1
>>> from sage.all import *
>>> f = Zp(Integer(5)).coerce_map_from(ZZ).section()
>>> f(Zp(Integer(5))(-Integer(1))) - Integer(5)**Integer(20)
-1
class sage.rings.padics.padic_capped_relative_element.pAdicConvert_CR_QQ

Bases: RingMap

The map from the capped relative ring back to the rationals that returns a rational approximation of its input.

EXAMPLES:

sage: f = Qp(5).coerce_map_from(QQ).section(); f
Set-theoretic ring morphism:
  From: 5-adic Field with capped relative precision 20
  To:   Rational Field
>>> from sage.all import *
>>> f = Qp(Integer(5)).coerce_map_from(QQ).section(); f
Set-theoretic ring morphism:
  From: 5-adic Field with capped relative precision 20
  To:   Rational Field
class sage.rings.padics.padic_capped_relative_element.pAdicConvert_CR_ZZ

Bases: RingMap

The map from a capped relative ring back to the ring of integers that returns the smallest nonnegative integer approximation to its input which is accurate up to the precision.

Raises a ValueError, if the input is not in the closure of the image of the integers.

EXAMPLES:

sage: f = Zp(5).coerce_map_from(ZZ).section(); f
Set-theoretic ring morphism:
  From: 5-adic Ring with capped relative precision 20
  To:   Integer Ring
>>> from sage.all import *
>>> f = Zp(Integer(5)).coerce_map_from(ZZ).section(); f
Set-theoretic ring morphism:
  From: 5-adic Ring with capped relative precision 20
  To:   Integer Ring
class sage.rings.padics.padic_capped_relative_element.pAdicConvert_CR_frac_field

Bases: Morphism

The section of the inclusion from \(\ZZ_q\) to its fraction field.

EXAMPLES:

sage: # needs sage.libs.flint
sage: R.<a> = ZqCR(27, implementation='FLINT')
sage: K = R.fraction_field()
sage: f = R.convert_map_from(K); f
Generic morphism:
  From: 3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
>>> from sage.all import *
>>> # needs sage.libs.flint
>>> R = ZqCR(Integer(27), implementation='FLINT', names=('a',)); (a,) = R._first_ngens(1)
>>> K = R.fraction_field()
>>> f = R.convert_map_from(K); f
Generic morphism:
  From: 3-adic Unramified Extension Field in a defined by x^3 + 2*x + 1
  To:   3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
class sage.rings.padics.padic_capped_relative_element.pAdicConvert_QQ_CR

Bases: Morphism

The inclusion map from the rationals to a capped relative ring that is defined on all elements with nonnegative \(p\)-adic valuation.

EXAMPLES:

sage: f = Zp(5).convert_map_from(QQ); f
Generic morphism:
  From: Rational Field
  To:   5-adic Ring with capped relative precision 20
>>> from sage.all import *
>>> f = Zp(Integer(5)).convert_map_from(QQ); f
Generic morphism:
  From: Rational Field
  To:   5-adic Ring with capped relative precision 20
section()

Return the map back to the rationals that returns the smallest nonnegative integer approximation to its input which is accurate up to the precision.

EXAMPLES:

sage: f = Zp(5,4).convert_map_from(QQ).section()
sage: f(Zp(5,4)(-1))
-1
>>> from sage.all import *
>>> f = Zp(Integer(5),Integer(4)).convert_map_from(QQ).section()
>>> f(Zp(Integer(5),Integer(4))(-Integer(1)))
-1
class sage.rings.padics.padic_capped_relative_element.pAdicTemplateElement

Bases: pAdicGenericElement

A class for common functionality among the \(p\)-adic template classes.

INPUT:

  • parent – a local ring or field

  • x – data defining this element. Various types are supported, including ints, Integers, Rationals, PARI \(p\)-adics, integers mod \(p^k\) and other Sage \(p\)-adics.

  • absprec – a cap on the absolute precision of this element

  • relprec – a cap on the relative precision of this element

EXAMPLES:

sage: Zp(17)(17^3, 8, 4)
17^3 + O(17^7)
>>> from sage.all import *
>>> Zp(Integer(17))(Integer(17)**Integer(3), Integer(8), Integer(4))
17^3 + O(17^7)
expansion(n=None, lift_mode='simple', start_val=None)

Return the coefficients in a \(\pi\)-adic expansion. If this is a field element, start at \(\pi^{\mbox{valuation}}\), if a ring element at \(\pi^0\).

For each lift mode, this function returns a list of \(a_i\) so that this element can be expressed as

\[\pi^v \cdot \sum_{i=0}^\infty a_i \pi^i,\]

where \(v\) is the valuation of this element when the parent is a field, and \(v = 0\) otherwise.

Different lift modes affect the choice of \(a_i\). When lift_mode is 'simple', the resulting \(a_i\) will be nonnegative: if the residue field is \(\GF{p}\) then they will be integers with \(0 \le a_i < p\); otherwise they will be a list of integers in the same range giving the coefficients of a polynomial in the indeterminant representing the maximal unramified subextension.

Choosing lift_mode as 'smallest' is similar to 'simple', but uses a balanced representation \(-p/2 < a_i \le p/2\).

Finally, setting lift_mode = 'teichmuller' will yield Teichmuller representatives for the \(a_i\): \(a_i^q = a_i\). In this case the \(a_i\) will lie in the ring of integers of the maximal unramified subextension of the parent of this element.

INPUT:

  • n – integer (default: None); if given, returns the corresponding entry in the expansion. Can also accept a slice (see slice()).

  • lift_mode'simple', 'smallest' or 'teichmuller' (default: 'simple')

  • start_val – start at this valuation rather than the default (\(0\) or the valuation of this element)

OUTPUT:

  • If n is None, an iterable giving a \(\pi\)-adic expansion of this element. For base elements the contents will be integers if lift_mode is 'simple' or 'smallest', and elements of self.parent() if lift_mode is 'teichmuller'.

  • If n is an integer, the coefficient of \(\pi^n\) in the \(\pi\)-adic expansion of this element.

Note

Use slice operators to get a particular range.

EXAMPLES:

sage: R = Zp(7,6); a = R(12837162817); a
3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
sage: E = a.expansion(); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
sage: list(E)
[3, 4, 4, 0, 4, 0]
sage: sum([c * 7^i for i, c in enumerate(E)]) == a
True
sage: E = a.expansion(lift_mode='smallest'); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6) (balanced)
sage: list(E)
[3, -3, -2, 1, -3, 1]
sage: sum([c * 7^i for i, c in enumerate(E)]) == a
True
sage: E = a.expansion(lift_mode='teichmuller'); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6) (teichmuller)
sage: list(E)
[3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5 + O(7^6),
0,
5 + 2*7 + 3*7^3 + O(7^4),
1 + O(7^3),
3 + 4*7 + O(7^2),
5 + O(7)]
sage: sum(c * 7^i for i, c in enumerate(E))
3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
>>> from sage.all import *
>>> R = Zp(Integer(7),Integer(6)); a = R(Integer(12837162817)); a
3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
>>> E = a.expansion(); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)
>>> list(E)
[3, 4, 4, 0, 4, 0]
>>> sum([c * Integer(7)**i for i, c in enumerate(E)]) == a
True
>>> E = a.expansion(lift_mode='smallest'); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6) (balanced)
>>> list(E)
[3, -3, -2, 1, -3, 1]
>>> sum([c * Integer(7)**i for i, c in enumerate(E)]) == a
True
>>> E = a.expansion(lift_mode='teichmuller'); E
7-adic expansion of 3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6) (teichmuller)
>>> list(E)
[3 + 4*7 + 6*7^2 + 3*7^3 + 2*7^5 + O(7^6),
0,
5 + 2*7 + 3*7^3 + O(7^4),
1 + O(7^3),
3 + 4*7 + O(7^2),
5 + O(7)]
>>> sum(c * Integer(7)**i for i, c in enumerate(E))
3 + 4*7 + 4*7^2 + 4*7^4 + O(7^6)

If the element has positive valuation then the list will start with some zeros:

sage: a = R(7^3 * 17)
sage: E = a.expansion(); E
7-adic expansion of 3*7^3 + 2*7^4 + O(7^9)
sage: list(E)
[0, 0, 0, 3, 2, 0, 0, 0, 0]
>>> from sage.all import *
>>> a = R(Integer(7)**Integer(3) * Integer(17))
>>> E = a.expansion(); E
7-adic expansion of 3*7^3 + 2*7^4 + O(7^9)
>>> list(E)
[0, 0, 0, 3, 2, 0, 0, 0, 0]

The expansion of 0 is truncated:

sage: E = R(0, 7).expansion(); E
7-adic expansion of O(7^7)
sage: len(E)
0
sage: list(E)
[]
>>> from sage.all import *
>>> E = R(Integer(0), Integer(7)).expansion(); E
7-adic expansion of O(7^7)
>>> len(E)
0
>>> list(E)
[]

In fields, on the other hand, the expansion starts at the valuation:

sage: R = Qp(7,4); a = R(6*7+7**2); E = a.expansion(); E
7-adic expansion of 6*7 + 7^2 + O(7^5)
sage: list(E)
[6, 1, 0, 0]
sage: list(a.expansion(lift_mode='smallest'))
[-1, 2, 0, 0]
sage: list(a.expansion(lift_mode='teichmuller'))
[6 + 6*7 + 6*7^2 + 6*7^3 + O(7^4),
2 + 4*7 + 6*7^2 + O(7^3),
3 + 4*7 + O(7^2),
3 + O(7)]
>>> from sage.all import *
>>> R = Qp(Integer(7),Integer(4)); a = R(Integer(6)*Integer(7)+Integer(7)**Integer(2)); E = a.expansion(); E
7-adic expansion of 6*7 + 7^2 + O(7^5)
>>> list(E)
[6, 1, 0, 0]
>>> list(a.expansion(lift_mode='smallest'))
[-1, 2, 0, 0]
>>> list(a.expansion(lift_mode='teichmuller'))
[6 + 6*7 + 6*7^2 + 6*7^3 + O(7^4),
2 + 4*7 + 6*7^2 + O(7^3),
3 + 4*7 + O(7^2),
3 + O(7)]

You can ask for a specific entry in the expansion:

sage: a.expansion(1)
6
sage: a.expansion(1, lift_mode='smallest')
-1
sage: a.expansion(2, lift_mode='teichmuller')
2 + 4*7 + 6*7^2 + O(7^3)
>>> from sage.all import *
>>> a.expansion(Integer(1))
6
>>> a.expansion(Integer(1), lift_mode='smallest')
-1
>>> a.expansion(Integer(2), lift_mode='teichmuller')
2 + 4*7 + 6*7^2 + O(7^3)
lift_to_precision(absprec=None)

Return another element of the same parent with absolute precision at least absprec, congruent to this \(p\)-adic element modulo the precision of this element.

INPUT:

  • absprec – integer or None (default: None); the absolute precision of the result. If None, lifts to the maximum precision allowed.

Note

If setting absprec that high would violate the precision cap, raises a precision error. Note that the new digits will not necessarily be zero.

EXAMPLES:

sage: R = ZpCA(17)
sage: R(-1,2).lift_to_precision(10)
16 + 16*17 + O(17^10)
sage: R(1,15).lift_to_precision(10)
1 + O(17^15)
sage: R(1,15).lift_to_precision(30)
Traceback (most recent call last):
...
PrecisionError: precision higher than allowed by the precision cap
sage: R(-1,2).lift_to_precision().precision_absolute() == R.precision_cap()
True

sage: R = Zp(5); c = R(17,3); c.lift_to_precision(8)
2 + 3*5 + O(5^8)
sage: c.lift_to_precision().precision_relative() == R.precision_cap()
True
>>> from sage.all import *
>>> R = ZpCA(Integer(17))
>>> R(-Integer(1),Integer(2)).lift_to_precision(Integer(10))
16 + 16*17 + O(17^10)
>>> R(Integer(1),Integer(15)).lift_to_precision(Integer(10))
1 + O(17^15)
>>> R(Integer(1),Integer(15)).lift_to_precision(Integer(30))
Traceback (most recent call last):
...
PrecisionError: precision higher than allowed by the precision cap
>>> R(-Integer(1),Integer(2)).lift_to_precision().precision_absolute() == R.precision_cap()
True

>>> R = Zp(Integer(5)); c = R(Integer(17),Integer(3)); c.lift_to_precision(Integer(8))
2 + 3*5 + O(5^8)
>>> c.lift_to_precision().precision_relative() == R.precision_cap()
True

Fixed modulus elements don’t raise errors:

sage: R = ZpFM(5); a = R(5); a.lift_to_precision(7)
5
sage: a.lift_to_precision(10000)
5
>>> from sage.all import *
>>> R = ZpFM(Integer(5)); a = R(Integer(5)); a.lift_to_precision(Integer(7))
5
>>> a.lift_to_precision(Integer(10000))
5
residue(absprec=1, field=None, check_prec=True)

Reduce this element modulo \(p^\mathrm{absprec}\).

INPUT:

  • absprec0 or 1

  • field – boolean (default: None); for precision 1, whether to return an element of the residue field or a residue ring. Currently unused.

  • check_prec – boolean (default: True); whether to raise an error if this element has insufficient precision to determine the reduction. Errors are never raised for fixed-mod or floating-point types.

OUTPUT:

This element reduced modulo \(p^\mathrm{absprec}\) as an element of the residue field or the null ring.

EXAMPLES:

sage: # needs sage.libs.ntl
sage: R.<a> = Zq(27, 4)
sage: (3 + 3*a).residue()
0
sage: (a + 1).residue()
a0 + 1
>>> from sage.all import *
>>> # needs sage.libs.ntl
>>> R = Zq(Integer(27), Integer(4), names=('a',)); (a,) = R._first_ngens(1)
>>> (Integer(3) + Integer(3)*a).residue()
0
>>> (a + Integer(1)).residue()
a0 + 1
teichmuller_expansion(n=None)

Return an iterator over coefficients \(a_0, a_1, \dots, a_n\) such that

  • \(a_i^q = a_i\), where \(q\) is the cardinality of the residue field,

  • this element can be expressed as

\[\pi^v \cdot \sum_{i=0}^\infty a_i \pi^i\]

where \(v\) is the valuation of this element when the parent is a field, and \(v = 0\) otherwise.

  • if \(a_i \ne 0\), the precision of \(a_i\) is \(i\) less than the precision of this element (relative in the case that the parent is a field, absolute otherwise)

Note

The coefficients will lie in the ring of integers of the maximal unramified subextension.

INPUT:

  • n – integer (default: None); if given, returns the coefficient of \(\pi^n\) in the expansion

EXAMPLES:

For fields, the expansion starts at the valuation:

sage: R = Qp(5,5); list(R(70).teichmuller_expansion())
[4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5),
3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4),
2 + 5 + 2*5^2 + O(5^3),
1 + O(5^2),
4 + O(5)]
>>> from sage.all import *
>>> R = Qp(Integer(5),Integer(5)); list(R(Integer(70)).teichmuller_expansion())
[4 + 4*5 + 4*5^2 + 4*5^3 + 4*5^4 + O(5^5),
3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4),
2 + 5 + 2*5^2 + O(5^3),
1 + O(5^2),
4 + O(5)]

But if you specify n, you get the coefficient of \(\pi^n\):

sage: R(70).teichmuller_expansion(2)
3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4)
>>> from sage.all import *
>>> R(Integer(70)).teichmuller_expansion(Integer(2))
3 + 3*5 + 2*5^2 + 3*5^3 + O(5^4)
unit_part()

Return the unit part of this element.

This is the \(p\)-adic element \(u\) in the same ring so that this element is \(\pi^v u\), where \(\pi\) is a uniformizer and \(v\) is the valuation of this element.

EXAMPLES:

sage: # needs sage.libs.ntl
sage: R.<a> = Zq(125)
sage: (5*a).unit_part()
a + O(5^20)
>>> from sage.all import *
>>> # needs sage.libs.ntl
>>> R = Zq(Integer(125), names=('a',)); (a,) = R._first_ngens(1)
>>> (Integer(5)*a).unit_part()
a + O(5^20)
sage.rings.padics.padic_capped_relative_element.unpickle_cre_v2(cls, parent, unit, ordp, relprec)

Unpickles a capped relative element.

EXAMPLES:

sage: from sage.rings.padics.padic_capped_relative_element import unpickle_cre_v2
sage: R = Zp(5); a = R(85,6)
sage: b = unpickle_cre_v2(a.__class__, R, 17, 1, 5)
sage: a == b
True
sage: a.precision_relative() == b.precision_relative()
True
>>> from sage.all import *
>>> from sage.rings.padics.padic_capped_relative_element import unpickle_cre_v2
>>> R = Zp(Integer(5)); a = R(Integer(85),Integer(6))
>>> b = unpickle_cre_v2(a.__class__, R, Integer(17), Integer(1), Integer(5))
>>> a == b
True
>>> a.precision_relative() == b.precision_relative()
True
sage.rings.padics.padic_capped_relative_element.unpickle_pcre_v1(R, unit, ordp, relprec)

Unpickles a capped relative element.

EXAMPLES:

sage: from sage.rings.padics.padic_capped_relative_element import unpickle_pcre_v1
sage: R = Zp(5)
sage: a = unpickle_pcre_v1(R, 17, 2, 5); a
2*5^2 + 3*5^3 + O(5^7)
>>> from sage.all import *
>>> from sage.rings.padics.padic_capped_relative_element import unpickle_pcre_v1
>>> R = Zp(Integer(5))
>>> a = unpickle_pcre_v1(R, Integer(17), Integer(2), Integer(5)); a
2*5^2 + 3*5^3 + O(5^7)