Dynamical systems on Berkovich space over \(\CC_p\).¶

A dynamical system on Berkovich space over \(\CC_p\) is determined by a dynamical system on \(A^1(\CC_p)\) or \(P^1(\CC_p)\), which naturally induces a dynamical system on affine or projective Berkovich space.

For an exposition of dynamical systems on Berkovich space, see chapter 7 of [Ben2019], or for a more involved exposition, chapter 2 of [BR2010].

AUTHORS:

Alexander Galarraga (August 14th, 2020): initial implementation

class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich(dynamical_system, domain)[source]¶

Bases: Element

A dynamical system on Berkovich space over \(\CC_p\).

INPUT:

dynamical_system – a DynamicalSystem over affine or projective space. If this input is not defined over a \(p\)-adic field, then domain MUST be specified.
domain – (optional) affine or projective Berkovich space over \(\CC_p\). domain must be specified if dynamical_system is defined over a number field.
ideal – (optional) an ideal of the base_ring of the domain of dynamical_system. Used to create domain as a Berkovich space backed by a number field more efficiently, see examples.

EXAMPLES:

We can easily create a dynamical system on Berkovich space using a dynamical system on projective space over \(\QQ_p\):

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([2*x^2 + 4*y^2, 3*x^2 + 9*y^2])
sage: DynamicalSystem_Berkovich(f)
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        ((2 + O(3^20))*x^2 + (1 + 3 + O(3^20))*y^2
         : (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) + Integer(4)*y**Integer(2), Integer(3)*x**Integer(2) + Integer(9)*y**Integer(2)])
>>> DynamicalSystem_Berkovich(f)
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        ((2 + O(3^20))*x^2 + (1 + 3 + O(3^20))*y^2
         : (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([2*x^2 + 4*y^2, 3*x^2 + 9*y^2])
DynamicalSystem_Berkovich(f)

Or directly from polynomials:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3),1)
sage: DynamicalSystem_Berkovich([x^2 + y^2, y^2])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), y**Integer(2)])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3),1)
DynamicalSystem_Berkovich([x^2 + y^2, y^2])

DynamicalSystem_Berkovich defaults to projective:

Sage

sage: R.<x,y> = Qp(3)[]
sage: DynamicalSystem_Berkovich([x^2, y^2])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 : y^2)

Python

>>> from sage.all import *
>>> R = Qp(Integer(3))['x, y']; (x, y,) = R._first_ngens(2)
>>> DynamicalSystem_Berkovich([x**Integer(2), y**Integer(2)])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 : y^2)

Sage Live

R.<x,y> = Qp(3)[]
DynamicalSystem_Berkovich([x^2, y^2])

To create an affine dynamical system on Berkovich space, pass an affine dynamical system to DynamicalSystem_Berkovich:

Sage

sage: A.<z> = AffineSpace(Qp(3), 1)
sage: f = DynamicalSystem_affine(z^2 + 1)
sage: DynamicalSystem_Berkovich(f)
Dynamical system of Affine Berkovich line over Cp(3) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (z) to
        (z^2 + 1 + O(3^20))

Python

>>> from sage.all import *
>>> A = AffineSpace(Qp(Integer(3)), Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine(z**Integer(2) + Integer(1))
>>> DynamicalSystem_Berkovich(f)
Dynamical system of Affine Berkovich line over Cp(3) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (z) to
        (z^2 + 1 + O(3^20))

Sage Live

A.<z> = AffineSpace(Qp(3), 1)
f = DynamicalSystem_affine(z^2 + 1)
DynamicalSystem_Berkovich(f)

domain can be used to specify the type of dynamical system:

Sage

sage: A.<z> = AffineSpace(Qp(3), 1)
sage: C = Berkovich_Cp_Affine(3)
sage: DynamicalSystem_Berkovich([z^2 + 1], C)
Dynamical system of Affine Berkovich line over Cp(3) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (z) to
        (z^2 + 1 + O(3^20))

Python

>>> from sage.all import *
>>> A = AffineSpace(Qp(Integer(3)), Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> C = Berkovich_Cp_Affine(Integer(3))
>>> DynamicalSystem_Berkovich([z**Integer(2) + Integer(1)], C)
Dynamical system of Affine Berkovich line over Cp(3) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (z) to
        (z^2 + 1 + O(3^20))

Sage Live

A.<z> = AffineSpace(Qp(3), 1)
C = Berkovich_Cp_Affine(3)
DynamicalSystem_Berkovich([z^2 + 1], C)

We can create dynamical systems which act on Berkovich spaces backed by number fields:

Sage

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: A.<a> = NumberField(z^2 + 1)
sage: ideal = A.prime_above(2)
sage: P.<x,y> = ProjectiveSpace(A, 1)
sage: B = Berkovich_Cp_Projective(P, ideal)
sage: DynamicalSystem_Berkovich([x^2 + y^2, 2*a*x*y], B)
Dynamical system of Projective Berkovich line over Cp(2), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : (2*a)*x*y)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(2) + Integer(1), names=('a',)); (a,) = A._first_ngens(1)
>>> ideal = A.prime_above(Integer(2))
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> B = Berkovich_Cp_Projective(P, ideal)
>>> DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), Integer(2)*a*x*y], B)
Dynamical system of Projective Berkovich line over Cp(2), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : (2*a)*x*y)

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^2 + 1)
ideal = A.prime_above(2)
P.<x,y> = ProjectiveSpace(A, 1)
B = Berkovich_Cp_Projective(P, ideal)
DynamicalSystem_Berkovich([x^2 + y^2, 2*a*x*y], B)

We can use the optional parameter ideal to create the same dynamical system more efficiently:

Sage

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: A.<a> = NumberField(z^2 + 1)
sage: prime_ideal = A.prime_above(2)
sage: P.<x,y> = ProjectiveSpace(A, 1)
sage: DynamicalSystem_Berkovich([x^2 + y^2, 2*a*x*y], ideal=prime_ideal)
Dynamical system of Projective Berkovich line over Cp(2), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : (2*a)*x*y)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(2) + Integer(1), names=('a',)); (a,) = A._first_ngens(1)
>>> prime_ideal = A.prime_above(Integer(2))
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), Integer(2)*a*x*y], ideal=prime_ideal)
Dynamical system of Projective Berkovich line over Cp(2), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + y^2 : (2*a)*x*y)

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^2 + 1)
prime_ideal = A.prime_above(2)
P.<x,y> = ProjectiveSpace(A, 1)
DynamicalSystem_Berkovich([x^2 + y^2, 2*a*x*y], ideal=prime_ideal)

Creating a map on Berkovich space creates the Berkovich space it acts on:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([x^2, y^2])
sage: g = DynamicalSystem_Berkovich(f)
sage: B = g.domain(); B
Projective Berkovich line over Cp(3) of precision 20

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_Berkovich(f)
>>> B = g.domain(); B
Projective Berkovich line over Cp(3) of precision 20

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([x^2, y^2])
g = DynamicalSystem_Berkovich(f)
B = g.domain(); B

The image of type I point is the image of the center:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: F = DynamicalSystem_Berkovich([x^2, y^2])
sage: B = F.domain()
sage: Q1 = B(2)
sage: F(Q1)
Type I point centered at (1 + 3 + O(3^20) : 1 + O(3^20))

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_Berkovich([x**Integer(2), y**Integer(2)])
>>> B = F.domain()
>>> Q1 = B(Integer(2))
>>> F(Q1)
Type I point centered at (1 + 3 + O(3^20) : 1 + O(3^20))

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
F = DynamicalSystem_Berkovich([x^2, y^2])
B = F.domain()
Q1 = B(2)
F(Q1)

For type II/III points with no poles in the corresponding disk, the image is the type II/III point corresponding to the image of the disk:

Sage

sage: Q2 = B(0, 3)
sage: F(Q2)
Type II point centered at (0 : 1 + O(3^20)) of radius 3^2

Python

>>> from sage.all import *
>>> Q2 = B(Integer(0), Integer(3))
>>> F(Q2)
Type II point centered at (0 : 1 + O(3^20)) of radius 3^2

Sage Live

Q2 = B(0, 3)
F(Q2)

The image of any type II point can be computed:

Sage

sage: g = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: G = DynamicalSystem_Berkovich(g)
sage: Q3 = B(0, 1)
sage: G(Q3)
Type II point centered at (0 : 1 + O(3^20)) of radius 3^0

Python

>>> from sage.all import *
>>> g = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> G = DynamicalSystem_Berkovich(g)
>>> Q3 = B(Integer(0), Integer(1))
>>> G(Q3)
Type II point centered at (0 : 1 + O(3^20)) of radius 3^0

Sage Live

g = DynamicalSystem_projective([x^2 + y^2, x*y])
G = DynamicalSystem_Berkovich(g)
Q3 = B(0, 1)
G(Q3)

The image of type III points can be computed has long as the corresponding disk contains no poles of the dynamical system:

Sage

sage: Q4 = B(1/9, 1.5)
sage: G(Q4)
Type III point centered at (3^-2 + 3^2 + O(3^18) : 1 + O(3^20))
of radius 1.50000000000000

Python

>>> from sage.all import *
>>> Q4 = B(Integer(1)/Integer(9), RealNumber('1.5'))
>>> G(Q4)
Type III point centered at (3^-2 + 3^2 + O(3^18) : 1 + O(3^20))
of radius 1.50000000000000

Sage Live

Q4 = B(1/9, 1.5)
G(Q4)

Sometimes, however, the poles are contained in an extension of \(\QQ_p\) that Sage does not support:

Sage

sage: H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3])
sage: H(Q4) # not tested
Traceback (most recent call last):
...
NotImplementedError: cannot check if poles lie in type III disk

Python

>>> from sage.all import *
>>> H = DynamicalSystem_Berkovich([x*y**Integer(2), x**Integer(3) + Integer(20)*y**Integer(3)])
>>> H(Q4) # not tested
Traceback (most recent call last):
...
NotImplementedError: cannot check if poles lie in type III disk

Sage Live

H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3])
H(Q4) # not tested

Q4, however, does not contain any poles of H (this can be checked using pencil and paper or the number field functionality in Sage). There are two ways around this error: the first and simplest is to have H act on a Berkovich space backed by a number field:

Sage

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: B = Berkovich_Cp_Projective(P, 3)
sage: H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3], B)
sage: Q4 = B(1/9, 1.5)
sage: H(Q4)                                                                     # needs sage.rings.number_field
Type III point centered at (81/14581 : 1) of radius 0.00205761316872428

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> B = Berkovich_Cp_Projective(P, Integer(3))
>>> H = DynamicalSystem_Berkovich([x*y**Integer(2), x**Integer(3) + Integer(20)*y**Integer(3)], B)
>>> Q4 = B(Integer(1)/Integer(9), RealNumber('1.5'))
>>> H(Q4)                                                                     # needs sage.rings.number_field
Type III point centered at (81/14581 : 1) of radius 0.00205761316872428

Sage Live

P.<x,y> = ProjectiveSpace(QQ, 1)
B = Berkovich_Cp_Projective(P, 3)
H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3], B)
Q4 = B(1/9, 1.5)
H(Q4)                                                                     # needs sage.rings.number_field

Alternatively, if checking for poles in the disk has been done already, type_3_pole_check can be set to False:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3])
sage: B = H.domain()
sage: Q4 = B(1/9, 1.5)
sage: H(Q4, False)
Type III point centered at (3^4 + 3^10 + 2*3^11 + 2*3^13 + 2*3^14 +
2*3^15 + 3^17 + 2*3^18 + 2*3^19 + 3^20 + 3^21 + 3^22 + O(3^24) : 1 +
O(3^20)) of radius 0.00205761316872428

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> H = DynamicalSystem_Berkovich([x*y**Integer(2), x**Integer(3) + Integer(20)*y**Integer(3)])
>>> B = H.domain()
>>> Q4 = B(Integer(1)/Integer(9), RealNumber('1.5'))
>>> H(Q4, False)
Type III point centered at (3^4 + 3^10 + 2*3^11 + 2*3^13 + 2*3^14 +
2*3^15 + 3^17 + 2*3^18 + 2*3^19 + 3^20 + 3^21 + 3^22 + O(3^24) : 1 +
O(3^20)) of radius 0.00205761316872428

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
H = DynamicalSystem_Berkovich([x*y^2, x^3 + 20*y^3])
B = H.domain()
Q4 = B(1/9, 1.5)
H(Q4, False)

WARNING: setting type_3_pole_check to False can lead to mathematically incorrect answers.

as_scheme_dynamical_system()[source]¶

Return this dynamical system as DynamicalSystem.

OUTPUT: an affine or projective DynamicalSystem

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_Berkovich([x^2 + y^2, x*y])
sage: f.as_scheme_dynamical_system()
Dynamical System of Projective Space of dimension 1 over
 3-adic Field with capped relative precision 20
  Defn: Defined on coordinates by sending (x : y) to (x^2 + y^2 : x*y)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), x*y])
>>> f.as_scheme_dynamical_system()
Dynamical System of Projective Space of dimension 1 over
 3-adic Field with capped relative precision 20
  Defn: Defined on coordinates by sending (x : y) to (x^2 + y^2 : x*y)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_Berkovich([x^2 + y^2, x*y])
f.as_scheme_dynamical_system()

base_ring()[source]¶

The base ring of this dynamical system, that is, the field of definition of the coefficients.

OUTPUT: a field

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_Berkovich([x^2 + y^2, y^2])
sage: f.base_ring()
3-adic Field with capped relative precision 20

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.base_ring()
3-adic Field with capped relative precision 20

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_Berkovich([x^2 + y^2, y^2])
f.base_ring()

Sage

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: A.<a> = NumberField(z^3 + 20)
sage: P.<x,y> = ProjectiveSpace(A, 1)
sage: f = DynamicalSystem_Berkovich([x^2, x^2 + y^2], ideal=A.prime_above(2))
sage: f.base_ring()
Number Field in a with defining polynomial z^3 + 20

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2), x**Integer(2) + y**Integer(2)], ideal=A.prime_above(Integer(2)))
>>> f.base_ring()
Number Field in a with defining polynomial z^3 + 20

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
P.<x,y> = ProjectiveSpace(A, 1)
f = DynamicalSystem_Berkovich([x^2, x^2 + y^2], ideal=A.prime_above(2))
f.base_ring()

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2), x**Integer(2) + y**Integer(2)], ideal=A.prime_above(Integer(2)))
>>> f.base_ring()
Number Field in a with defining polynomial z^3 + 20

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
P.<x,y> = ProjectiveSpace(A, 1)
f = DynamicalSystem_Berkovich([x^2, x^2 + y^2], ideal=A.prime_above(2))
f.base_ring()

defining_polynomials()[source]¶

Return the defining polynomials.

OUTPUT: a tuple of polynomials that defines the dynamical system.

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([2*x^2 + 4*y^2, 3*x^2 + 9*y^2])
sage: g = DynamicalSystem_Berkovich(f)
sage: g.defining_polynomials()
((2 + O(3^20))*x^2 + (1 + 3 + O(3^20))*y^2,
 (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) + Integer(4)*y**Integer(2), Integer(3)*x**Integer(2) + Integer(9)*y**Integer(2)])
>>> g = DynamicalSystem_Berkovich(f)
>>> g.defining_polynomials()
((2 + O(3^20))*x^2 + (1 + 3 + O(3^20))*y^2,
 (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([2*x^2 + 4*y^2, 3*x^2 + 9*y^2])
g = DynamicalSystem_Berkovich(f)
g.defining_polynomials()

domain()[source]¶

Return the domain of this dynamical system.

OUTPUT: a Berkovich space over Cp

EXAMPLES:

Sage

sage: Q.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([3*x^2, 2*y^2])
sage: g = DynamicalSystem_Berkovich(f)
sage: g.domain()
Projective Berkovich line over Cp(3) of precision 20

Python

>>> from sage.all import *
>>> Q = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = Q._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2), Integer(2)*y**Integer(2)])
>>> g = DynamicalSystem_Berkovich(f)
>>> g.domain()
Projective Berkovich line over Cp(3) of precision 20

Sage Live

Q.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([3*x^2, 2*y^2])
g = DynamicalSystem_Berkovich(f)
g.domain()

class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_affine(dynamical_system, domain)[source]¶

Bases: DynamicalSystem_Berkovich

A dynamical system of the affine Berkovich line over \(\CC_p\).

INPUT:

dynamical_system – a DynamicalSystem_affine of relative dimension 1
domain – (optional) affine or projective Berkovich space over \(\CC_p\). If the input to dynamical_system is not defined over \(\QQ_p\) or a finite extension, domain must be specified.

EXAMPLES:

A dynamical system of the affine Berkovich line is induced by a dynamical system on \(\QQ_p\) or an extension of \(\QQ_p\):

Sage

sage: A.<x> = AffineSpace(Qp(5), 1)
sage: f = DynamicalSystem_affine([(x^2 + 1)/x])
sage: DynamicalSystem_Berkovich(f)
Dynamical system of Affine Berkovich line over Cp(5) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (x) to ((x^2 + 1 + O(5^20))/x)

Python

>>> from sage.all import *
>>> A = AffineSpace(Qp(Integer(5)), Integer(1), names=('x',)); (x,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([(x**Integer(2) + Integer(1))/x])
>>> DynamicalSystem_Berkovich(f)
Dynamical system of Affine Berkovich line over Cp(5) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (x) to ((x^2 + 1 + O(5^20))/x)

Sage Live

A.<x> = AffineSpace(Qp(5), 1)
f = DynamicalSystem_affine([(x^2 + 1)/x])
DynamicalSystem_Berkovich(f)

Dynamical system can be created from a morphism:

Sage

sage: H = End(A)
sage: phi = H([x + 3])
sage: DynamicalSystem_Berkovich(phi)
Dynamical system of Affine Berkovich line over Cp(5) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (x) to (x + 3 + O(5^20))

Python

>>> from sage.all import *
>>> H = End(A)
>>> phi = H([x + Integer(3)])
>>> DynamicalSystem_Berkovich(phi)
Dynamical system of Affine Berkovich line over Cp(5) of precision 20 induced by the map
  Defn: Defined on coordinates by sending (x) to (x + 3 + O(5^20))

Sage Live

H = End(A)
phi = H([x + 3])
DynamicalSystem_Berkovich(phi)

homogenize(n)[source]¶

Return the homogenization of this dynamical system.

For dynamical systems of Berkovich space, this is the dynamical system of projective Berkovich space induced by the homogenization of the dynamical system.

INPUT:

n – tuple of nonnegative integers. If \(n\) is an integer, then the two values of the tuple are assumed to be the same

OUTPUT: a dynamical system on projective Berkovich space

EXAMPLES:

Sage

sage: A.<x> = AffineSpace(Qp(3), 1)
sage: f = DynamicalSystem_affine(1/x)
sage: f = DynamicalSystem_Berkovich(f)
sage: f.homogenize(1)
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x0 : x1) to (x1 : x0)

Python

>>> from sage.all import *
>>> A = AffineSpace(Qp(Integer(3)), Integer(1), names=('x',)); (x,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine(Integer(1)/x)
>>> f = DynamicalSystem_Berkovich(f)
>>> f.homogenize(Integer(1))
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x0 : x1) to (x1 : x0)

Sage Live

A.<x> = AffineSpace(Qp(3), 1)
f = DynamicalSystem_affine(1/x)
f = DynamicalSystem_Berkovich(f)
f.homogenize(1)

class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_projective(dynamical_system, domain=None)[source]¶

Bases: DynamicalSystem_Berkovich

A dynamical system on projective Berkovich space over \(\CC_p\).

A dynamical system on projective Berkovich space over \(\CC_p\) is determined by a dynamical system on \(A^1(\CC_p)\) or \(P^1(\CC_p)\), which naturally induces a dynamical system on affine or projective Berkovich space.

INPUT:

dynamical_system – a DynamicalSystem_Projective of relative dimension 1. If this input is not defined over a \(p\)-adic field, then domain MUST be specified.
domain – (optional) projective Berkovich space over \(\CC_p\). If the input to dynamical_system is not defined over a \(p\)-adic field, domain must be specified.

EXAMPLES:

We can easily create a dynamical system on Berkovich space using a dynamical system on projective space over \(\QQ_p\):

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([1/2*x^2 + x*y + 3*y^2, 3*x^2 + 9*y^2])
sage: DynamicalSystem_Berkovich(f)
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        ((2 + 3 + 3^2 + 3^3 + 3^4 + 3^5 + 3^6 + 3^7 + 3^8 + 3^9 + 3^10 + 3^11
        + 3^12 + 3^13 + 3^14 + 3^15 + 3^16 + 3^17 + 3^18 + 3^19 + O(3^20))*x^2
        + x*y + (3 + O(3^21))*y^2 : (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1)/Integer(2)*x**Integer(2) + x*y + Integer(3)*y**Integer(2), Integer(3)*x**Integer(2) + Integer(9)*y**Integer(2)])
>>> DynamicalSystem_Berkovich(f)
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        ((2 + 3 + 3^2 + 3^3 + 3^4 + 3^5 + 3^6 + 3^7 + 3^8 + 3^9 + 3^10 + 3^11
        + 3^12 + 3^13 + 3^14 + 3^15 + 3^16 + 3^17 + 3^18 + 3^19 + O(3^20))*x^2
        + x*y + (3 + O(3^21))*y^2 : (3 + O(3^21))*x^2 + (3^2 + O(3^22))*y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([1/2*x^2 + x*y + 3*y^2, 3*x^2 + 9*y^2])
DynamicalSystem_Berkovich(f)

Or from a morphism:

Sage

sage: P1.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: H = End(P1)
sage: DynamicalSystem_Berkovich(H([y, x]))
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (y : x)

Python

>>> from sage.all import *
>>> P1 = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P1._first_ngens(2)
>>> H = End(P1)
>>> DynamicalSystem_Berkovich(H([y, x]))
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (y : x)

Sage Live

P1.<x,y> = ProjectiveSpace(Qp(3), 1)
H = End(P1)
DynamicalSystem_Berkovich(H([y, x]))

Or from polynomials:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: DynamicalSystem_Berkovich([x^2+y^2, y^2])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^2 + y^2 : y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> DynamicalSystem_Berkovich([x**Integer(2)+y**Integer(2), y**Integer(2)])
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^2 + y^2 : y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
DynamicalSystem_Berkovich([x^2+y^2, y^2])

conjugate(M, adjugate=False, new_ideal=None)[source]¶

Conjugate this dynamical system by M, i.e. \(M^{-1} \circ f \circ M\).

If possible the new map will be defined over the same space. Otherwise, will try to coerce to the base ring of M.

INPUT:

M – a square invertible matrix
adjugate – boolean (default: False); also classically called adjoint, takes a square matrix M and finds the transpose of its cofactor matrix. Used for conjugation in place of inverse when specified 'True'. Functionality is the same in projective space.
new_ideal – (optional) an ideal of the base_ring of M. Used to specify an extension in the case where M is not defined over the same number field as this dynamical system.

OUTPUT: a dynamical system

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
sage: g = DynamicalSystem_Berkovich(f)
sage: g.conjugate(Matrix([[1, 1], [0, 1]]))
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + (2 + O(3^20))*x*y : (2 + O(3^20))*y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*y**Integer(2)])
>>> g = DynamicalSystem_Berkovich(f)
>>> g.conjugate(Matrix([[Integer(1), Integer(1)], [Integer(0), Integer(1)]]))
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + (2 + O(3^20))*x*y : (2 + O(3^20))*y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
g = DynamicalSystem_Berkovich(f)
g.conjugate(Matrix([[1, 1], [0, 1]]))

Sage

sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_Berkovich([x^2 + y^2, y^2], ideal=5)
sage: R.<z> = QQ[]
sage: A.<a> = NumberField(z^2 + 1)
sage: conj = Matrix([[1, a], [0, 1]])
sage: f.conjugate(conj)
Dynamical system of Projective Berkovich line over Cp(5), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + (2*a)*x*y + (-a)*y^2 : y^2)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), y**Integer(2)], ideal=Integer(5))
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(2) + Integer(1), names=('a',)); (a,) = A._first_ngens(1)
>>> conj = Matrix([[Integer(1), a], [Integer(0), Integer(1)]])
>>> f.conjugate(conj)
Dynamical system of Projective Berkovich line over Cp(5), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + (2*a)*x*y + (-a)*y^2 : y^2)

Sage Live

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_Berkovich([x^2 + y^2, y^2], ideal=5)
R.<z> = QQ[]
A.<a> = NumberField(z^2 + 1)
conj = Matrix([[1, a], [0, 1]])
f.conjugate(conj)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), y**Integer(2)], ideal=Integer(5))
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(2) + Integer(1), names=('a',)); (a,) = A._first_ngens(1)
>>> conj = Matrix([[Integer(1), a], [Integer(0), Integer(1)]])
>>> f.conjugate(conj)
Dynamical system of Projective Berkovich line over Cp(5), with base Number Field
in a with defining polynomial z^2 + 1 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + (2*a)*x*y + (-a)*y^2 : y^2)

Sage Live

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_Berkovich([x^2 + y^2, y^2], ideal=5)
R.<z> = QQ[]
A.<a> = NumberField(z^2 + 1)
conj = Matrix([[1, a], [0, 1]])
f.conjugate(conj)

We can use new_ideal to specify a new domain when the base ring of M and of this dynamical system are not the same:

Sage

sage: # needs sage.rings.number_field
sage: ideal = A.ideal(5).factor()[1][0]; ideal
Fractional ideal (2*a + 1)
sage: g = f.conjugate(conj, new_ideal=ideal)
sage: g.domain().ideal()
Fractional ideal (2*a + 1)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> ideal = A.ideal(Integer(5)).factor()[Integer(1)][Integer(0)]; ideal
Fractional ideal (2*a + 1)
>>> g = f.conjugate(conj, new_ideal=ideal)
>>> g.domain().ideal()
Fractional ideal (2*a + 1)

Sage Live

# needs sage.rings.number_field
ideal = A.ideal(5).factor()[1][0]; ideal
g = f.conjugate(conj, new_ideal=ideal)
g.domain().ideal()

dehomogenize(n)[source]¶

Return the map induced by the standard dehomogenization.

The dehomogenization is done at the n[0] coordinate of the domain and the n[1] coordinate of the codomain.

INPUT:

n – tuple of nonnegative integers; if \(n\) is an integer, then the two values of the tuple are assumed to be the same

OUTPUT: a dynamical system on affine Berkovich space

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y + y^2])
sage: g = DynamicalSystem_Berkovich(f)
sage: g.dehomogenize(1)
Dynamical system of Affine Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x) to
        ((x^2 + 1 + O(3^20))/(x + 1 + O(3^20)))

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y + y**Integer(2)])
>>> g = DynamicalSystem_Berkovich(f)
>>> g.dehomogenize(Integer(1))
Dynamical system of Affine Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x) to
        ((x^2 + 1 + O(3^20))/(x + 1 + O(3^20)))

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_projective([x^2 + y^2, x*y + y^2])
g = DynamicalSystem_Berkovich(f)
g.dehomogenize(1)

normalize_coordinates()[source]¶

Normalize the coordinates of the inducing map.

OUTPUT: none

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_Berkovich([2*x^2, 2*y^2])
sage: f.normalize_coordinates(); f
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^2 : y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([Integer(2)*x**Integer(2), Integer(2)*y**Integer(2)])
>>> f.normalize_coordinates(); f
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^2 : y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_Berkovich([2*x^2, 2*y^2])
f.normalize_coordinates(); f

Normalize_coordinates may sometimes fail over \(p\)-adic fields:

Sage

sage: g = DynamicalSystem_Berkovich([2*x^2, x*y])
sage: g.normalize_coordinates()  # not tested
Traceback (most recent call last):
...
TypeError: unable to coerce since the denominator is not 1

Python

>>> from sage.all import *
>>> g = DynamicalSystem_Berkovich([Integer(2)*x**Integer(2), x*y])
>>> g.normalize_coordinates()  # not tested
Traceback (most recent call last):
...
TypeError: unable to coerce since the denominator is not 1

Sage Live

g = DynamicalSystem_Berkovich([2*x^2, x*y])
g.normalize_coordinates()  # not tested

To fix this issue, create a system on Berkovich space backed by a number field:

Sage

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: B = Berkovich_Cp_Projective(P, 3)
sage: g = DynamicalSystem_Berkovich([2*x^2, x*y], B)
sage: g.normalize_coordinates(); g
Dynamical system of Projective Berkovich line over Cp(3), with base Rational Field
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (2*x : y)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> B = Berkovich_Cp_Projective(P, Integer(3))
>>> g = DynamicalSystem_Berkovich([Integer(2)*x**Integer(2), x*y], B)
>>> g.normalize_coordinates(); g
Dynamical system of Projective Berkovich line over Cp(3), with base Rational Field
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (2*x : y)

Sage Live

P.<x,y> = ProjectiveSpace(QQ, 1)
B = Berkovich_Cp_Projective(P, 3)
g = DynamicalSystem_Berkovich([2*x^2, x*y], B)
g.normalize_coordinates(); g

resultant(normalize=False)[source]¶

Compute the resultant of the defining polynomials of this dynamical system.

If normalize is True, then first normalize the coordinate functions with normalize_coordinates().

INPUT:

normalize – boolean (default: False)

OUTPUT: an element of the base ring of this map

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_Berkovich([x^2 + y^2, y^2])
sage: f.resultant()
1 + O(3^20)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.resultant()
1 + O(3^20)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_Berkovich([x^2 + y^2, y^2])
f.resultant()

Sage

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: A.<a> = NumberField(z^3 + 20)
sage: P.<x,y> = ProjectiveSpace(A, 1)
sage: f = DynamicalSystem_Berkovich([2*x^2, x^2 + y^2], ideal=A.prime_above(2))
sage: f.resultant()
4

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([Integer(2)*x**Integer(2), x**Integer(2) + y**Integer(2)], ideal=A.prime_above(Integer(2)))
>>> f.resultant()
4

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
P.<x,y> = ProjectiveSpace(A, 1)
f = DynamicalSystem_Berkovich([2*x^2, x^2 + y^2], ideal=A.prime_above(2))
f.resultant()

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([Integer(2)*x**Integer(2), x**Integer(2) + y**Integer(2)], ideal=A.prime_above(Integer(2)))
>>> f.resultant()
4

Sage Live

# needs sage.rings.number_field
R.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
P.<x,y> = ProjectiveSpace(A, 1)
f = DynamicalSystem_Berkovich([2*x^2, x^2 + y^2], ideal=A.prime_above(2))
f.resultant()

scale_by(t)[source]¶

Scale each coordinate of this dynamical system by a factor of \(t\).

INPUT:

t – a ring element

OUTPUT: none

EXAMPLES:

Sage

sage: P.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: f = DynamicalSystem_Berkovich([x^2, y^2])
sage: f.scale_by(x); f
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^3 : x*y^2)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_Berkovich([x**Integer(2), y**Integer(2)])
>>> f.scale_by(x); f
Dynamical system of Projective Berkovich line over Cp(3) of precision 20
 induced by the map
  Defn: Defined on coordinates by sending (x : y) to (x^3 : x*y^2)

Sage Live

P.<x,y> = ProjectiveSpace(Qp(3), 1)
f = DynamicalSystem_Berkovich([x^2, y^2])
f.scale_by(x); f

Sage

sage: # needs sage.rings.number_field
sage: Q.<z> = QQ[]
sage: A.<a> = NumberField(z^3 + 20)
sage: ideal = A.prime_above(3)
sage: P.<x,y> = ProjectiveSpace(A, 1)
sage: B = Berkovich_Cp_Projective(P, ideal)
sage: f = DynamicalSystem_Berkovich([x^2 + y^2, 2*x*y], B)
sage: f.scale_by(2); f
Dynamical system of Projective Berkovich line over Cp(3), with base Number
Field in a with defining polynomial z^3 + 20 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 2*y^2 : 4*x*y)

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> Q = QQ['z']; (z,) = Q._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> ideal = A.prime_above(Integer(3))
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> B = Berkovich_Cp_Projective(P, ideal)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), Integer(2)*x*y], B)
>>> f.scale_by(Integer(2)); f
Dynamical system of Projective Berkovich line over Cp(3), with base Number
Field in a with defining polynomial z^3 + 20 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 2*y^2 : 4*x*y)

Sage Live

# needs sage.rings.number_field
Q.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
ideal = A.prime_above(3)
P.<x,y> = ProjectiveSpace(A, 1)
B = Berkovich_Cp_Projective(P, ideal)
f = DynamicalSystem_Berkovich([x^2 + y^2, 2*x*y], B)
f.scale_by(2); f

Python

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> Q = QQ['z']; (z,) = Q._first_ngens(1)
>>> A = NumberField(z**Integer(3) + Integer(20), names=('a',)); (a,) = A._first_ngens(1)
>>> ideal = A.prime_above(Integer(3))
>>> P = ProjectiveSpace(A, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> B = Berkovich_Cp_Projective(P, ideal)
>>> f = DynamicalSystem_Berkovich([x**Integer(2) + y**Integer(2), Integer(2)*x*y], B)
>>> f.scale_by(Integer(2)); f
Dynamical system of Projective Berkovich line over Cp(3), with base Number
Field in a with defining polynomial z^3 + 20 induced by the map
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 2*y^2 : 4*x*y)

Sage Live

# needs sage.rings.number_field
Q.<z> = QQ[]
A.<a> = NumberField(z^3 + 20)
ideal = A.prime_above(3)
P.<x,y> = ProjectiveSpace(A, 1)
B = Berkovich_Cp_Projective(P, ideal)
f = DynamicalSystem_Berkovich([x^2 + y^2, 2*x*y], B)
f.scale_by(2); f