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)

Bases: Element

A dynamical system 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.

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: 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)

Or directly from polynomials:

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)

DynamicalSystem_Berkovich defaults to projective:

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)

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

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))

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

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))

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

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)

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

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)

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

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

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

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))

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: Q2 = B(0, 3)
sage: F(Q2)
Type II point centered at (0 : 1 + O(3^20)) of radius 3^2

The image of any type II point can be computed:

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

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

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

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

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

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: 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)
Type III point centered at (81/14581 : 1) of radius 0.00205761316872428

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

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

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

as_scheme_dynamical_system()

Return this dynamical system as DynamicalSystem.

OUTPUT: An affine or projective DynamicalSystem.

EXAMPLES:

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)

base_ring()

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

OUTPUT: A field.

EXAMPLES:

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

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

defining_polynomials()

Return the defining polynomials.

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

EXAMPLES:

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)

domain()

Return the domain of this dynamical system.

OUTPUT: A Berkovich space over Cp.

EXAMPLES:

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

class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_affine(dynamical_system, domain)

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: 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)

Dynamical system can be created from a morphism:

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))

homogenize(n)

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 – a 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: 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)

class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_projective(dynamical_system, domain=None)

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: 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)

Or from a morphism:

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)

Or from polynomials:

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)

conjugate(M, adjugate=False, new_ideal=None)

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 – (default: False) boolean, 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: 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)

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)

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: 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)

dehomogenize(n)

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 – a 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: 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)))

normalize_coordinates()

Normalizes the coordinates of the inducing map.

OUTPUT: None.

EXAMPLES:

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)

Normalize_coordinates may sometimes fail over p-adic fields:

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

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

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)

resultant(normalize=False)

Computes 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 – (default: False) boolean.

OUTPUT: an element of the base ring of this map.

EXAMPLES:

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)

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

scale_by(t)

Scales each coordinate of this dynamical system by a factor of t.

INPUT:

• t – a ring element.

OUTPUT: None.

EXAMPLES:

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)

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)