Tate algebras

Let \(K\) be a finite extension of \(\Bold{Q}_p\) for some prime number \(p\) and let \((v_1, \dots, v_n)\) be a tuple of real numbers.

The associated Tate algebra consists of series of the form

\[\sum_{i_1,\dots,i_n \in \NN} a_{i_1,\dots,i_n} x_1^{i_1} \cdots x_n^{i_n}\]

for which the quantity

\[\operatorname{val}(a_{i_1,\dots,i_n}) - (v_1 i_1 + \cdots + v_n i_n)\]

goes to infinity when the multi-index \((i_1,\dots,i_n)\) goes to infinity.

These series converge on the closed disc defined by the inequalities \(\operatorname{val}(x_i) \geq -v_i\) for all \(i \in \{1,\dots,n\}\). The \(v_i\)’s are then the logarithms of the radii of convergence of the series in the above Tate algebra; the will be called the log radii of convergence.

We can create Tate algebras using the constructor sage.rings.tate_algebra.TateAlgebra():

sage: K = Qp(2, 5, print_mode='digits')
sage: A.<x,y> = TateAlgebra(K); A
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5

>>> from sage.all import *
>>> K = Qp(Integer(2), Integer(5), print_mode='digits')
>>> A = TateAlgebra(K, names=('x', 'y',)); (x, y,) = A._first_ngens(2); A
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5

K = Qp(2, 5, print_mode='digits')
A.<x,y> = TateAlgebra(K); A

As we observe, the default value for the log radii of convergence is \(0\) (the series then converge on the closed unit disc).

We can specify different log radii using the following syntax:

sage: B.<u,v> = TateAlgebra(K, log_radii=[1,2]); B
Tate Algebra in u (val >= -1), v (val >= -2)
 over 2-adic Field with capped relative precision 5

>>> from sage.all import *
>>> B = TateAlgebra(K, log_radii=[Integer(1),Integer(2)], names=('u', 'v',)); (u, v,) = B._first_ngens(2); B
Tate Algebra in u (val >= -1), v (val >= -2)
 over 2-adic Field with capped relative precision 5

B.<u,v> = TateAlgebra(K, log_radii=[1,2]); B

Note that if we pass in the ring of integers of \(p\)-adic field, the same Tate algebra is returned:

sage: A1.<x,y> = TateAlgebra(K.integer_ring()); A1
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5
sage: A is A1
True

>>> from sage.all import *
>>> A1 = TateAlgebra(K.integer_ring(), names=('x', 'y',)); (x, y,) = A1._first_ngens(2); A1
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5
>>> A is A1
True

A1.<x,y> = TateAlgebra(K.integer_ring()); A1
A is A1

However the method integer_ring() constructs the integer ring of a Tate algebra, that is the subring consisting of series bounded by \(1\) on the domain of convergence:

sage: Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5

>>> from sage.all import *
>>> Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 5

Ao = A.integer_ring(); Ao

Now we can build elements:

sage: f = 5 + 2*x*y^3 + 4*x^2*y^2; f
...00101 + ...000010*x*y^3 + ...0000100*x^2*y^2
sage: g = x^3*y + 2*x*y; g
...00001*x^3*y + ...000010*x*y

>>> from sage.all import *
>>> f = Integer(5) + Integer(2)*x*y**Integer(3) + Integer(4)*x**Integer(2)*y**Integer(2); f
...00101 + ...000010*x*y^3 + ...0000100*x^2*y^2
>>> g = x**Integer(3)*y + Integer(2)*x*y; g
...00001*x^3*y + ...000010*x*y

f = 5 + 2*x*y^3 + 4*x^2*y^2; f
g = x^3*y + 2*x*y; g

and perform all usual arithmetic operations on them:

sage: f + g
...00001*x^3*y + ...00101 + ...000010*x*y^3 + ...000010*x*y + ...0000100*x^2*y^2
sage: f * g
...00101*x^3*y + ...000010*x^4*y^4 + ...001010*x*y
 + ...0000100*x^5*y^3 + ...0000100*x^2*y^4 + ...00001000*x^3*y^3

>>> from sage.all import *
>>> f + g
...00001*x^3*y + ...00101 + ...000010*x*y^3 + ...000010*x*y + ...0000100*x^2*y^2
>>> f * g
...00101*x^3*y + ...000010*x^4*y^4 + ...001010*x*y
 + ...0000100*x^5*y^3 + ...0000100*x^2*y^4 + ...00001000*x^3*y^3

f + g
f * g

An element in the integer ring is invertible if and only if its reduction modulo \(p\) is a nonzero constant. In our example, \(f\) is invertible (its reduction modulo \(2\) is \(1\)) but \(g\) is not:

sage: f.inverse_of_unit()
...01101 + ...01110*x*y^3 + ...10100*x^2*y^6 + ... + O(2^5 * <x, y>)
sage: g.inverse_of_unit()
Traceback (most recent call last):
...
ValueError: this series in not invertible

>>> from sage.all import *
>>> f.inverse_of_unit()
...01101 + ...01110*x*y^3 + ...10100*x^2*y^6 + ... + O(2^5 * <x, y>)
>>> g.inverse_of_unit()
Traceback (most recent call last):
...
ValueError: this series in not invertible

f.inverse_of_unit()
g.inverse_of_unit()

The notation \(O(2^5)\) in the result above hides a series which lies in \(2^5\) times the integer ring of \(A\), that is a series which is bounded by \(|2^5|\) (\(2\)-adic norm) on the domain of convergence.

We can also evaluate series in a point of the domain of convergence (in the base field or in an extension):

sage: L.<a> = Qq(2^3, 5)
sage: f(a^2, 2*a)
1 + 2^2 + a*2^4 + O(2^5)

sage: u = polygen(ZZ, 'u')
sage: L.<pi> = K.change(print_mode='series').extension(u^3 - 2)
sage: g(pi, 2*pi)
pi^7 + pi^8 + pi^19 + pi^20 + O(pi^21)

>>> from sage.all import *
>>> L = Qq(Integer(2)**Integer(3), Integer(5), names=('a',)); (a,) = L._first_ngens(1)
>>> f(a**Integer(2), Integer(2)*a)
1 + 2^2 + a*2^4 + O(2^5)

>>> u = polygen(ZZ, 'u')
>>> L = K.change(print_mode='series').extension(u**Integer(3) - Integer(2), names=('pi',)); (pi,) = L._first_ngens(1)
>>> g(pi, Integer(2)*pi)
pi^7 + pi^8 + pi^19 + pi^20 + O(pi^21)

L.<a> = Qq(2^3, 5)
f(a^2, 2*a)
u = polygen(ZZ, 'u')
L.<pi> = K.change(print_mode='series').extension(u^3 - 2)
g(pi, 2*pi)

Computations with ideals in Tate algebras are also supported:

sage: f = 7*x^3*y + 2*x*y - x*y^2 - 6*y^5
sage: g = x*y^4 + 8*x^3 - 3*y^3 + 1
sage: I = A.ideal([f, g])
sage: I.groebner_basis()
[...00001*x^2*y^3 + ...00001*y^4 + ...10001*x^2 + ... + O(2^5 * <x, y>),
 ...00001*x*y^4 + ...11101*y^3 + ...00001 + ... + O(2^5 * <x, y>),
 ...00001*y^5 + ...11111*x*y^3 + ...01001*x^2*y + ... + O(2^5 * <x, y>),
 ...00001*x^3 + ...01001*x*y + ...10110*y^4 + ...01110*x + O(2^5 * <x, y>)]

sage: (x^2 + 3*y)*f + 1/2*(x^3*y + x*y)*g in I
True

>>> from sage.all import *
>>> f = Integer(7)*x**Integer(3)*y + Integer(2)*x*y - x*y**Integer(2) - Integer(6)*y**Integer(5)
>>> g = x*y**Integer(4) + Integer(8)*x**Integer(3) - Integer(3)*y**Integer(3) + Integer(1)
>>> I = A.ideal([f, g])
>>> I.groebner_basis()
[...00001*x^2*y^3 + ...00001*y^4 + ...10001*x^2 + ... + O(2^5 * <x, y>),
 ...00001*x*y^4 + ...11101*y^3 + ...00001 + ... + O(2^5 * <x, y>),
 ...00001*y^5 + ...11111*x*y^3 + ...01001*x^2*y + ... + O(2^5 * <x, y>),
 ...00001*x^3 + ...01001*x*y + ...10110*y^4 + ...01110*x + O(2^5 * <x, y>)]

>>> (x**Integer(2) + Integer(3)*y)*f + Integer(1)/Integer(2)*(x**Integer(3)*y + x*y)*g in I
True

f = 7*x^3*y + 2*x*y - x*y^2 - 6*y^5
g = x*y^4 + 8*x^3 - 3*y^3 + 1
I = A.ideal([f, g])
I.groebner_basis()
(x^2 + 3*y)*f + 1/2*(x^3*y + x*y)*g in I

AUTHORS:

  • Xavier Caruso, Thibaut Verron (2018-09)

class sage.rings.tate_algebra.TateAlgebraFactory[source]

Bases: UniqueFactory

Construct a Tate algebra over a \(p\)-adic field.

Given a \(p\)-adic field \(K\), variables \(X_1,\dots,X_k\) and convergence log radii \(v_1, \dots, v_n\) in \(\RR\), the corresponding Tate algebra \(K{X_1,\dots,X_k}\) consists of power series with coefficients \(a_{i_1,\dots,i_n}\) in \(K\) such that

\[\operatorname{val}(a_{i_1,\dots,i_n}) - (i_1 v_1 + \cdots + i_n v_n)\]

tends to infinity as \(i_1,\dots,i_n\) go towards infinity.

INPUT:

  • base – a \(p\)-adic ring or field; if a ring is given, the Tate algebra over its fraction field will be constructed

  • prec – integer or None (default: None); the precision cap. It is used if an exact object must be truncated in order to do an arithmetic operation. If left as None, it will be set to the precision cap of the base field.

  • log_radii – integer or a list or a tuple of integers (default: 0); the value(s) \(v_i\). If an integer is given, this will be the common value for all \(v_i\).

  • names – names of the indeterminates

  • order – the monomial ordering (default: degrevlex) used to break ties when comparing terms with the same coefficient valuation

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits'); R
2-adic Ring with capped relative precision 10
sage: A.<x,y> = TateAlgebra(R, order='lex'); A
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 10

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits'); R
2-adic Ring with capped relative precision 10
>>> A = TateAlgebra(R, order='lex', names=('x', 'y',)); (x, y,) = A._first_ngens(2); A
Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 10

R = Zp(2, 10, print_mode='digits'); R
A.<x,y> = TateAlgebra(R, order='lex'); A

We observe that the result is the Tate algebra over the fraction field of \(R\) and not \(R\) itself:

sage: A.base_ring()
2-adic Field with capped relative precision 10
sage: A.base_ring() is R.fraction_field()
True

>>> from sage.all import *
>>> A.base_ring()
2-adic Field with capped relative precision 10
>>> A.base_ring() is R.fraction_field()
True

A.base_ring()
A.base_ring() is R.fraction_field()

If we want to construct the ring of integers of the Tate algebra, we must use the method integer_ring():

sage: Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 10
sage: Ao.base_ring()
2-adic Ring with capped relative precision 10
sage: Ao.base_ring() is R
True

>>> from sage.all import *
>>> Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0)
 over 2-adic Field with capped relative precision 10
>>> Ao.base_ring()
2-adic Ring with capped relative precision 10
>>> Ao.base_ring() is R
True

Ao = A.integer_ring(); Ao
Ao.base_ring()
Ao.base_ring() is R

The term ordering is used (in particular) to determine how series are displayed. Terms are compared first according to the valuation of their coefficient, and ties are broken using the monomial ordering:

sage: A.term_order()
Lexicographic term order
sage: f = 2 + y^5 + x^2; f
...0000000001*x^2 + ...0000000001*y^5 + ...00000000010
sage: B.<x,y> = TateAlgebra(R); B
Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
sage: B.term_order()
Degree reverse lexicographic term order
sage: B(f)
...0000000001*y^5 + ...0000000001*x^2 + ...00000000010

>>> from sage.all import *
>>> A.term_order()
Lexicographic term order
>>> f = Integer(2) + y**Integer(5) + x**Integer(2); f
...0000000001*x^2 + ...0000000001*y^5 + ...00000000010
>>> B = TateAlgebra(R, names=('x', 'y',)); (x, y,) = B._first_ngens(2); B
Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
>>> B.term_order()
Degree reverse lexicographic term order
>>> B(f)
...0000000001*y^5 + ...0000000001*x^2 + ...00000000010

A.term_order()
f = 2 + y^5 + x^2; f
B.<x,y> = TateAlgebra(R); B
B.term_order()
B(f)

Here are examples of Tate algebra with smaller radii of convergence:

sage: B.<x,y> = TateAlgebra(R, log_radii=-1); B
Tate Algebra in x (val >= 1), y (val >= 1) over 2-adic Field with capped relative precision 10
sage: C.<x,y> = TateAlgebra(R, log_radii=[-1,-2]); C
Tate Algebra in x (val >= 1), y (val >= 2) over 2-adic Field with capped relative precision 10

>>> from sage.all import *
>>> B = TateAlgebra(R, log_radii=-Integer(1), names=('x', 'y',)); (x, y,) = B._first_ngens(2); B
Tate Algebra in x (val >= 1), y (val >= 1) over 2-adic Field with capped relative precision 10
>>> C = TateAlgebra(R, log_radii=[-Integer(1),-Integer(2)], names=('x', 'y',)); (x, y,) = C._first_ngens(2); C
Tate Algebra in x (val >= 1), y (val >= 2) over 2-adic Field with capped relative precision 10

B.<x,y> = TateAlgebra(R, log_radii=-1); B
C.<x,y> = TateAlgebra(R, log_radii=[-1,-2]); C

AUTHORS:

  • Xavier Caruso, Thibaut Verron (2018-09)

create_key(base, prec=None, log_radii=0, names=None, order='degrevlex')[source]

Create a key from the input parameters.

INPUT:

  • base – a \(p\)-adic ring or field

  • prec – integer or None (default: None)

  • log_radii – integer or a list or a tuple of integers (default: 0)

  • names – names of the indeterminates

  • order – a monomial ordering (default: degrevlex)

EXAMPLES:

sage: TateAlgebra.create_key(Zp(2), names=['x','y'])
(2-adic Field with capped relative precision 20,
 20,
 (0, 0),
 ('x', 'y'),
 Degree reverse lexicographic term order)

>>> from sage.all import *
>>> TateAlgebra.create_key(Zp(Integer(2)), names=['x','y'])
(2-adic Field with capped relative precision 20,
 20,
 (0, 0),
 ('x', 'y'),
 Degree reverse lexicographic term order)

TateAlgebra.create_key(Zp(2), names=['x','y'])
create_object(version, key)[source]

Create an object using the given key.

class sage.rings.tate_algebra.TateAlgebra_generic(field, prec, log_radii, names, order, integral=False)[source]

Bases: Parent

Initialize the Tate algebra.

absolute_e()[source]

Return the absolute index of ramification of this Tate algebra.

It is equal to the absolute index of ramification of the field of coefficients.

EXAMPLES:

sage: R = Zp(2)
sage: A.<u,v> = TateAlgebra(R)
sage: A.absolute_e()
1

sage: R.<a> = Zq(2^3)
sage: A.<u,v> = TateAlgebra(R)
sage: A.absolute_e()
1

sage: x = polygen(ZZ, 'x')
sage: S.<a> = R.extension(x^2 - 2)
sage: A.<u,v> = TateAlgebra(S)
sage: A.absolute_e()
2

>>> from sage.all import *
>>> R = Zp(Integer(2))
>>> A = TateAlgebra(R, names=('u', 'v',)); (u, v,) = A._first_ngens(2)
>>> A.absolute_e()
1

>>> R = Zq(Integer(2)**Integer(3), names=('a',)); (a,) = R._first_ngens(1)
>>> A = TateAlgebra(R, names=('u', 'v',)); (u, v,) = A._first_ngens(2)
>>> A.absolute_e()
1

>>> x = polygen(ZZ, 'x')
>>> S = R.extension(x**Integer(2) - Integer(2), names=('a',)); (a,) = S._first_ngens(1)
>>> A = TateAlgebra(S, names=('u', 'v',)); (u, v,) = A._first_ngens(2)
>>> A.absolute_e()
2

R = Zp(2)
A.<u,v> = TateAlgebra(R)
A.absolute_e()
R.<a> = Zq(2^3)
A.<u,v> = TateAlgebra(R)
A.absolute_e()
x = polygen(ZZ, 'x')
S.<a> = R.extension(x^2 - 2)
A.<u,v> = TateAlgebra(S)
A.absolute_e()
characteristic()[source]

Return the characteristic of this algebra.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.characteristic()
0

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.characteristic()
0

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.characteristic()
gen(n=0)[source]

Return the \(n\)-th generator of this Tate algebra.

INPUT:

  • n – integer (default: \(0\)); the index of the requested generator

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.gen()
...0000000001*x
sage: A.gen(0)
...0000000001*x
sage: A.gen(1)
...0000000001*y
sage: A.gen(2)
Traceback (most recent call last):
...
ValueError: generator not defined

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.gen()
...0000000001*x
>>> A.gen(Integer(0))
...0000000001*x
>>> A.gen(Integer(1))
...0000000001*y
>>> A.gen(Integer(2))
Traceback (most recent call last):
...
ValueError: generator not defined

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.gen()
A.gen(0)
A.gen(1)
A.gen(2)
gens()[source]

Return the list of generators of this Tate algebra.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.gens()
(...0000000001*x, ...0000000001*y)

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.gens()
(...0000000001*x, ...0000000001*y)

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.gens()
integer_ring()[source]

Return the ring of integers (consisting of series bounded by 1 in the domain of convergence) of this Tate algebra.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: Ao = A.integer_ring()
sage: Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10

sage: x in Ao
True
sage: x/2 in Ao
False

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> Ao = A.integer_ring()
>>> Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10

>>> x in Ao
True
>>> x/Integer(2) in Ao
False

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
Ao = A.integer_ring()
Ao
x in Ao
x/2 in Ao
is_integral_domain(proof=True)[source]

Return True since any Tate algebra is an integral domain.

EXAMPLES:

sage: A.<x,y> = TateAlgebra(Zp(3))
sage: A.is_integral_domain()
True

>>> from sage.all import *
>>> A = TateAlgebra(Zp(Integer(3)), names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.is_integral_domain()
True

A.<x,y> = TateAlgebra(Zp(3))
A.is_integral_domain()
log_radii()[source]

Return the list of the log-radii of convergence radii defining this Tate algebra.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: A.log_radii()
(0, 0)

sage: B.<x,y> = TateAlgebra(R, log_radii=1)
sage: B.log_radii()
(1, 1)

sage: C.<x,y> = TateAlgebra(R, log_radii=(1,-1))
sage: C.log_radii()
(1, -1)

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.log_radii()
(0, 0)

>>> B = TateAlgebra(R, log_radii=Integer(1), names=('x', 'y',)); (x, y,) = B._first_ngens(2)
>>> B.log_radii()
(1, 1)

>>> C = TateAlgebra(R, log_radii=(Integer(1),-Integer(1)), names=('x', 'y',)); (x, y,) = C._first_ngens(2)
>>> C.log_radii()
(1, -1)

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
A.log_radii()
B.<x,y> = TateAlgebra(R, log_radii=1)
B.log_radii()
C.<x,y> = TateAlgebra(R, log_radii=(1,-1))
C.log_radii()
monoid_of_terms()[source]

Return the monoid of terms of this Tate algebra.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: A.monoid_of_terms()
Monoid of terms in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.monoid_of_terms()
Monoid of terms in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
A.monoid_of_terms()
ngens()[source]

Return the number of generators of this algebra.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.ngens()
2

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.ngens()
2

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.ngens()
precision_cap()[source]

Return the precision cap of this Tate algebra.

Note

The precision cap is the truncation precision used for arithmetic operations computed by successive approximations (as inversion).

EXAMPLES:

By default the precision cap is the precision cap of the field of coefficients:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: A.precision_cap()
10

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.precision_cap()
10

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
A.precision_cap()

But it could be different (either smaller or larger) if we ask to:

sage: A.<x,y> = TateAlgebra(R, prec=5)
sage: A.precision_cap()
5

sage: A.<x,y> = TateAlgebra(R, prec=20)
sage: A.precision_cap()
20

>>> from sage.all import *
>>> A = TateAlgebra(R, prec=Integer(5), names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.precision_cap()
5

>>> A = TateAlgebra(R, prec=Integer(20), names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.precision_cap()
20

A.<x,y> = TateAlgebra(R, prec=5)
A.precision_cap()
A.<x,y> = TateAlgebra(R, prec=20)
A.precision_cap()
prime()[source]

Return the prime, that is the characteristic of the residue field.

EXAMPLES:

sage: R = Zp(3)
sage: A.<x,y> = TateAlgebra(R)
sage: A.prime()
3

>>> from sage.all import *
>>> R = Zp(Integer(3))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.prime()
3

R = Zp(3)
A.<x,y> = TateAlgebra(R)
A.prime()
random_element(degree=2, terms=5, integral=False, prec=None)[source]

Return a random element of this Tate algebra.

INPUT:

  • degree – integer (default: 2); an upper bound on the total degree of the result

  • terms – integer (default: 5); the maximal number of terms of the result

  • integral – boolean (default: False); if True the result will be in the ring of integers

  • prec – (optional) an integer, the precision of the result

EXAMPLES:

sage: R = Zp(2, prec=10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.random_element()  # random
(...00101000.01)*y + ...1111011111*x^2 + ...0010010001*x*y
  + ...110000011 + ...010100100*y^2

sage: A.random_element(degree=5, terms=3)  # random
(...0101100.01)*x^2*y + (...01000011.11)*y^2 + ...00111011*x*y

sage: A.random_element(integral=True)  # random
...0001111101*x + ...1101110101 + ...00010010110*y
 + ...101110001100*x*y + ...000001100100*y^2

>>> from sage.all import *
>>> R = Zp(Integer(2), prec=Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.random_element()  # random
(...00101000.01)*y + ...1111011111*x^2 + ...0010010001*x*y
  + ...110000011 + ...010100100*y^2

>>> A.random_element(degree=Integer(5), terms=Integer(3))  # random
(...0101100.01)*x^2*y + (...01000011.11)*y^2 + ...00111011*x*y

>>> A.random_element(integral=True)  # random
...0001111101*x + ...1101110101 + ...00010010110*y
 + ...101110001100*x*y + ...000001100100*y^2

R = Zp(2, prec=10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.random_element()  # random
A.random_element(degree=5, terms=3)  # random
A.random_element(integral=True)  # random

Note that if we are already working on the ring of integers, specifying integral=False has no effect:

sage: Ao = A.integer_ring()
sage: f = Ao.random_element(integral=False); f  # random
...1100111011*x^2 + ...1110100101*x + ...1100001101*y
 + ...1110110001 + ...01011010110*y^2
sage: f in Ao
True

>>> from sage.all import *
>>> Ao = A.integer_ring()
>>> f = Ao.random_element(integral=False); f  # random
...1100111011*x^2 + ...1110100101*x + ...1100001101*y
 + ...1110110001 + ...01011010110*y^2
>>> f in Ao
True

Ao = A.integer_ring()
f = Ao.random_element(integral=False); f  # random
f in Ao

When the log radii are negative, integral series may have non integral coefficients:

sage: B.<x,y> = TateAlgebra(R, log_radii=[-1,-2])
sage: B.random_element(integral=True)  # random
(...1111111.001)*x*y + (...111000101.1)*x + (...11010111.01)*y^2
 + ...0010011011*y + ...0010100011000

>>> from sage.all import *
>>> B = TateAlgebra(R, log_radii=[-Integer(1),-Integer(2)], names=('x', 'y',)); (x, y,) = B._first_ngens(2)
>>> B.random_element(integral=True)  # random
(...1111111.001)*x*y + (...111000101.1)*x + (...11010111.01)*y^2
 + ...0010011011*y + ...0010100011000

B.<x,y> = TateAlgebra(R, log_radii=[-1,-2])
B.random_element(integral=True)  # random
some_elements()[source]

Return a list of elements in this Tate algebra.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.some_elements()
[0,
 ...00000000010,
 ...0000000001*x,
 ...0000000001*y,
 ...00000000010*x*y,
 ...00000000100,
 ...0000000001*x + ...00000000010,
 ...0000000001*y + ...00000000010,
 ...00000000010*x*y + ...00000000010,
 ...0000000010*x,
 ...0000000001*x + ...0000000001*y,
 ...0000000001*x + ...00000000010*x*y,
 ...0000000010*y,
 ...0000000001*y + ...00000000010*x*y,
 ...00000000100*x*y]

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.some_elements()
[0,
 ...00000000010,
 ...0000000001*x,
 ...0000000001*y,
 ...00000000010*x*y,
 ...00000000100,
 ...0000000001*x + ...00000000010,
 ...0000000001*y + ...00000000010,
 ...00000000010*x*y + ...00000000010,
 ...0000000010*x,
 ...0000000001*x + ...0000000001*y,
 ...0000000001*x + ...00000000010*x*y,
 ...0000000010*y,
 ...0000000001*y + ...00000000010*x*y,
 ...00000000100*x*y]

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.some_elements()
term_order()[source]

Return the monomial order used in this algebra.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: A.term_order()
Degree reverse lexicographic term order

sage: A.<x,y> = TateAlgebra(R, order='lex')
sage: A.term_order()
Lexicographic term order

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.term_order()
Degree reverse lexicographic term order

>>> A = TateAlgebra(R, order='lex', names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.term_order()
Lexicographic term order

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
A.term_order()
A.<x,y> = TateAlgebra(R, order='lex')
A.term_order()
variable_names()[source]

Return the names of the variables of this algebra.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: A.variable_names()
('x', 'y')

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> A.variable_names()
('x', 'y')

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
A.variable_names()
class sage.rings.tate_algebra.TateTermMonoid(A)[source]

Bases: Monoid_class, UniqueRepresentation

A base class for Tate algebra terms.

A term in a Tate algebra \(K\{X_1,\dots,X_n\}\) (resp. in its ring of integers) is a monomial in this ring.

Those terms form a pre-ordered monoid, with term multiplication and the term order of the parent Tate algebra.

Element[source]

alias of TateAlgebraTerm

algebra_of_series()[source]

Return the Tate algebra corresponding to this Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.algebra_of_series()
Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
sage: T.algebra_of_series() is A
True

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.algebra_of_series()
Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
>>> T.algebra_of_series() is A
True

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.algebra_of_series()
T.algebra_of_series() is A
base_ring()[source]

Return the base ring of this Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.base_ring()
2-adic Field with capped relative precision 10

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.base_ring()
2-adic Field with capped relative precision 10

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.base_ring()

We observe that the base field is not R but its fraction field:

sage: T.base_ring() is R
False
sage: T.base_ring() is R.fraction_field()
True

>>> from sage.all import *
>>> T.base_ring() is R
False
>>> T.base_ring() is R.fraction_field()
True

T.base_ring() is R
T.base_ring() is R.fraction_field()

If we really want to create an integral Tate algebra, we have to invoke the method integer_ring():

sage: Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
sage: Ao.base_ring()
2-adic Ring with capped relative precision 10
sage: Ao.base_ring() is R
True

>>> from sage.all import *
>>> Ao = A.integer_ring(); Ao
Integer ring of the Tate Algebra in x (val >= 0), y (val >= 0) over 2-adic Field with capped relative precision 10
>>> Ao.base_ring()
2-adic Ring with capped relative precision 10
>>> Ao.base_ring() is R
True

Ao = A.integer_ring(); Ao
Ao.base_ring()
Ao.base_ring() is R
gen(n=0)[source]

Return the \(n\)-th generator of this monoid of terms.

INPUT:

  • n – integer (default: \(0\)); the index of the requested generator

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.gen()
...0000000001*x
sage: T.gen(0)
...0000000001*x
sage: T.gen(1)
...0000000001*y
sage: T.gen(2)
Traceback (most recent call last):
...
ValueError: generator not defined

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.gen()
...0000000001*x
>>> T.gen(Integer(0))
...0000000001*x
>>> T.gen(Integer(1))
...0000000001*y
>>> T.gen(Integer(2))
Traceback (most recent call last):
...
ValueError: generator not defined

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.gen()
T.gen(0)
T.gen(1)
T.gen(2)
gens()[source]

Return the list of generators of this monoid of terms.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.gens()
(...0000000001*x, ...0000000001*y)

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.gens()
(...0000000001*x, ...0000000001*y)

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.gens()
log_radii()[source]

Return the log radii of convergence of this Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.log_radii()
(0, 0)

sage: B.<x,y> = TateAlgebra(R, log_radii=[1,2])
sage: B.monoid_of_terms().log_radii()
(1, 2)

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.log_radii()
(0, 0)

>>> B = TateAlgebra(R, log_radii=[Integer(1),Integer(2)], names=('x', 'y',)); (x, y,) = B._first_ngens(2)
>>> B.monoid_of_terms().log_radii()
(1, 2)

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.log_radii()
B.<x,y> = TateAlgebra(R, log_radii=[1,2])
B.monoid_of_terms().log_radii()
ngens()[source]

Return the number of variables in the Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.ngens()
2

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.ngens()
2

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.ngens()
prime()[source]

Return the prime, that is the characteristic of the residue field.

EXAMPLES:

sage: R = Zp(3)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.prime()
3

>>> from sage.all import *
>>> R = Zp(Integer(3))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.prime()
3

R = Zp(3)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.prime()
some_elements()[source]

Return a list of elements in this monoid of terms.

EXAMPLES:

sage: R = Zp(2, 10, print_mode='digits')
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.some_elements()
[...00000000010, ...0000000001*x, ...0000000001*y, ...00000000010*x*y]

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10), print_mode='digits')
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.some_elements()
[...00000000010, ...0000000001*x, ...0000000001*y, ...00000000010*x*y]

R = Zp(2, 10, print_mode='digits')
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.some_elements()
term_order()[source]

Return the term order on this Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.term_order()  # default term order is grevlex
Degree reverse lexicographic term order

sage: A.<x,y> = TateAlgebra(R, order='lex')
sage: T = A.monoid_of_terms()
sage: T.term_order()
Lexicographic term order

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.term_order()  # default term order is grevlex
Degree reverse lexicographic term order

>>> A = TateAlgebra(R, order='lex', names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.term_order()
Lexicographic term order

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.term_order()  # default term order is grevlex
A.<x,y> = TateAlgebra(R, order='lex')
T = A.monoid_of_terms()
T.term_order()
variable_names()[source]

Return the names of the variables of this Tate term monoid.

EXAMPLES:

sage: R = Zp(2, 10)
sage: A.<x,y> = TateAlgebra(R)
sage: T = A.monoid_of_terms()
sage: T.variable_names()
('x', 'y')

>>> from sage.all import *
>>> R = Zp(Integer(2), Integer(10))
>>> A = TateAlgebra(R, names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> T = A.monoid_of_terms()
>>> T.variable_names()
('x', 'y')

R = Zp(2, 10)
A.<x,y> = TateAlgebra(R)
T = A.monoid_of_terms()
T.variable_names()