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
– ADynamicalSystem
over affine or projective space. If this input is not defined over a p-adic field, thendomain
MUST be specified.domain
– (optional) affine or projective Berkovich space over \(\CC_p\).domain
must be specified ifdynamical_system
is defined over a number field.ideal
– (optional) an ideal of thebase_ring
of the domain ofdynamical_system
. Used to createdomain
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: # 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)
We can use the optional parameter
ideal
to create the same dynamical system more efficiently: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)
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 ofH
(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 haveH
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) # needs sage.rings.number_field 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 toFalse
: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
toFalse
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: # 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
- 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
– ADynamicalSystem_affine
of relative dimension 1.domain
– (optional) affine or projective Berkovich space over \(\CC_p\). If the input todynamical_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. Ifn
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
– aDynamicalSystem_Projective
of relative dimension 1. If this input is not defined over a p-adic field, thendomain
MUST be specified.domain
– (optional) projective Berkovich space over \(\CC_p\). If the input todynamical_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 matrixM
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 thebase_ring
ofM
. Used to specify an extension in the case whereM
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: # 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)
We can use
new_ideal
to specify a new domain when the base ring ofM
and of this dynamical system are not the same: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)
- dehomogenize(n)#
Return the map induced by the standard dehomogenization.
The dehomogenization is done at the
n[0]
coordinate of the domain and then[1]
coordinate of the codomain.INPUT:
n
– a tuple of nonnegative integers; ifn
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
isTrue
, then first normalize the coordinate functions withnormalize_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: # 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
- 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: # 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)