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:
ElementA 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– aDynamicalSystemover affine or projective space. If this input is not defined over a \(p\)-adic field, thendomainMUST be specified.domain– (optional) affine or projective Berkovich space over \(\CC_p\).domainmust be specified ifdynamical_systemis defined over a number field.ideal– (optional) an ideal of thebase_ringof the domain ofdynamical_system. Used to createdomainas 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)
>>> 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)
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)
>>> 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)
DynamicalSystem_Berkovichdefaults 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)
>>> 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)
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))
>>> 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))
domaincan 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))
>>> 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))
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)
>>> 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)
We can use the optional parameter
idealto 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)
>>> 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)
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
>>> 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
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))
>>> 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))
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
>>> 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
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
>>> 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
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
>>> 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
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
>>> 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
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 haveHact 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
>>> 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
Alternatively, if checking for poles in the disk has been done already,
type_3_pole_checkcan 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
>>> 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
WARNING: setting
type_3_pole_checktoFalsecan lead to mathematically incorrect answers.- as_scheme_dynamical_system()[source]¶
Return this dynamical system as
DynamicalSystem.OUTPUT: an affine or projective
DynamicalSystemEXAMPLES:
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)
>>> 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)
- base_ring()[source]¶
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
>>> 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: # 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
>>> 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
- defining_polynomials()[source]¶
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)
>>> 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)
- domain()[source]¶
Return the domain of this dynamical system.
OUTPUT: a Berkovich space over
CpEXAMPLES:
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
>>> 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
- class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_affine(dynamical_system, domain)[source]¶
Bases:
DynamicalSystem_BerkovichA dynamical system of the affine Berkovich line over \(\CC_p\).
INPUT:
dynamical_system– aDynamicalSystem_affineof relative dimension 1domain– (optional) affine or projective Berkovich space over \(\CC_p\). If the input todynamical_systemis not defined over \(\QQ_p\) or a finite extension,domainmust 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)
>>> 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)
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))
>>> 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))
- 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: 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)
>>> 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)
- class sage.dynamics.arithmetic_dynamics.berkovich_ds.DynamicalSystem_Berkovich_projective(dynamical_system, domain=None)[source]¶
Bases:
DynamicalSystem_BerkovichA 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_Projectiveof relative dimension 1. If this input is not defined over a \(p\)-adic field, thendomainMUST be specified.domain– (optional) projective Berkovich space over \(\CC_p\). If the input todynamical_systemis not defined over a \(p\)-adic field,domainmust 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)
>>> 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)
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)
>>> 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)
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)
>>> 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)
- 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 matrixadjugate– boolean (default:False); also classically called adjoint, takes a square matrixMand 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_ringofM. Used to specify an extension in the case whereMis 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)
>>> 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: # 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)
>>> 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)
We can use
new_idealto specify a new domain when the base ring ofMand 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)
>>> 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)
- dehomogenize(n)[source]¶
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– 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)))
>>> 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)))
- normalize_coordinates()[source]¶
Normalize 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 ((2 + O(3^20))*x^2 : (2 + O(3^20))*y^2)
>>> 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 ((2 + O(3^20))*x^2 : (2 + O(3^20))*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
>>> 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
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)
>>> 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)
- resultant(normalize=False)[source]¶
Compute the resultant of the defining polynomials of this dynamical system.
If
normalizeisTrue, then first normalize the coordinate functions withnormalize_coordinates().INPUT:
normalize– boolean (default:False)
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)
>>> 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: # 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
>>> 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
- 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: 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)
>>> 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: # 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)
>>> 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)