def __classcall_private__(cls, morphism_or_polys, domain=None, names=None):
r"""
Return the appropriate dynamical system on a scheme.
EXAMPLES::
sage: R.<t> = QQ[]
sage: DynamicalSystem(t^2 - 3)
Dynamical System of Projective Space of dimension 1 over Rational Field
Defn: Defined on coordinates by sending (X : Y) to
(X^2 - 3*Y^2 : Y^2)
"""
if isinstance(morphism_or_polys, SchemeMorphism_polynomial):
domain = morphism_or_polys.domain()
if domain is not None:
if is_AffineSpace(domain) or isinstance(
domain, AlgebraicScheme_subscheme_affine):
from sage.dynamics.arithmetic_dynamics.affine_ds import DynamicalSystem_affine
return DynamicalSystem_affine(morphism_or_polys, domain)
if is_Berkovich_Cp(domain):
from sage.dynamics.arithmetic_dynamics.berkovich_ds import DynamicalSystem_Berkovich
return DynamicalSystem_Berkovich(morphism_or_polys, domain)
from sage.dynamics.arithmetic_dynamics.projective_ds import DynamicalSystem_projective
return DynamicalSystem_projective(morphism_or_polys, domain, names)
def __classcall_private__(cls, dynamical_system, domain=None):
"""
Return the approapriate dynamical system on projective Berkovich space over ``Cp``.
EXAMPLES::
sage: P1.<x,y> = ProjectiveSpace(Qp(3), 1)
sage: from sage.dynamics.arithmetic_dynamics.berkovich_ds import DynamicalSystem_Berkovich_projective
sage: DynamicalSystem_Berkovich_projective([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)
"""
if not isinstance(dynamical_system, DynamicalSystem):
if not isinstance(dynamical_system, DynamicalSystem_projective):
dynamical_system = DynamicalSystem_projective(dynamical_system)
else:
raise TypeError(
'affine dynamical system passed to projective constructor')
R = dynamical_system.base_ring()
morphism_domain = dynamical_system.domain()
if not is_ProjectiveSpace(morphism_domain):
raise TypeError(
'the domain of dynamical_system must be projective space, not %s'
% morphism_domain)
if morphism_domain.dimension_relative() != 1:
raise ValueError('domain was not relative dimension 1')
if not isinstance(R, pAdicBaseGeneric):
if domain is None:
raise TypeError('dynamical system defined over %s, not p-adic, ' %morphism_domain.base_ring() + \
'and domain is None')
if not isinstance(domain, Berkovich_Cp_Projective):
raise TypeError(
'domain was %s, not a projective Berkovich space over Cp' %
domain)
if domain.base() != morphism_domain:
raise ValueError('base of domain was %s, with coordinate ring %s ' %(domain.base(), \
domain.base().coordinate_ring())+ 'while dynamical_system acts on %s, ' %morphism_domain + \
'with coordinate ring %s' %morphism_domain.coordinate_ring())
else:
domain = Berkovich_Cp_Projective(morphism_domain)
return typecall(cls, dynamical_system, domain)
def __classcall_private__(cls, dynamical_system, domain=None):
"""
Return the appropriate dynamical system on affine Berkovich space over ``Cp``.
EXAMPLES::
sage: A.<x> = AffineSpace(Qp(3), 1)
sage: from sage.dynamics.arithmetic_dynamics.berkovich_ds import DynamicalSystem_Berkovich_affine
sage: DynamicalSystem_Berkovich_affine(DynamicalSystem_affine(x^2))
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)
"""
if not isinstance(dynamical_system, DynamicalSystem):
if not isinstance(dynamical_system, DynamicalSystem_affine):
dynamical_system = DynamicalSystem_projective(dynamical_system)
else:
raise TypeError(
'projective dynamical system passed to affine constructor')
R = dynamical_system.base_ring()
morphism_domain = dynamical_system.domain()
if not is_AffineSpace(morphism_domain):
raise TypeError(
'the domain of dynamical_system must be affine space, not %s' %
morphism_domain)
if morphism_domain.dimension_relative() != 1:
raise ValueError('domain not relative dimension 1')
if not isinstance(R, pAdicBaseGeneric):
if domain is None:
raise TypeError('dynamical system defined over %s, not padic, ' %morphism_domain.base_ring() + \
'and domain was not specified')
if not isinstance(domain, Berkovich_Cp_Affine):
raise TypeError(
'domain was %s, not an affine Berkovich space over Cp' %
domain)
else:
domain = Berkovich_Cp_Affine(morphism_domain.base_ring())
return typecall(cls, dynamical_system, domain)
def nth_iterate_map(self, n):
r"""
Return the nth iterate of this dynamical system.
ALGORITHM:
Uses a form of successive squaring to reduce computations.
.. TODO:: This could be improved.
INPUT:
- ``n`` -- a positive integer
OUTPUT: A dynamical system of products of projective spaces
EXAMPLES::
sage: Z.<a,b,x,y,z> = ProductProjectiveSpaces([1 , 2], QQ)
sage: f = DynamicalSystem_projective([a^3, b^3, x^2, y^2, z^2], domain=Z)
sage: f.nth_iterate_map(3)
Dynamical System of Product of projective spaces P^1 x P^2 over
Rational Field
Defn: Defined by sending (a : b , x : y : z) to
(a^27 : b^27 , x^8 : y^8 : z^8).
"""
E = self.domain()
D = int(n)
if D < 0:
raise TypeError("iterate number must be a nonnegative integer")
N = sum([
E.ambient_space()[i].dimension_relative() + 1
for i in range(E.ambient_space().num_components())
])
F = list(self._polys)
Coord_ring = E.coordinate_ring()
if isinstance(Coord_ring, QuotientRing_generic):
PHI = [gen.lift() for gen in Coord_ring.gens()]
else:
PHI = list(Coord_ring.gens())
while D:
if D & 1:
PHI = [poly(*F) for poly in PHI]
if D > 1: #avoid extra iterate
F = [poly(*F) for poly in F] #'square'
D >>= 1
return DynamicalSystem_projective(PHI, domain=self.domain())
def __classcall_private__(cls, dynamical_system, domain=None, ideal=None):
"""
Return the appropriate dynamical system on Berkovich space.
EXAMPLES::
sage: R.<t> = Qp(3)[]
sage: f = DynamicalSystem_affine(t^2 - 3)
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 ((1 + O(3^20))*t) to
((1 + O(3^20))*t^2 + 2*3 + 2*3^2 + 2*3^3 + 2*3^4 + 2*3^5 + 2*3^6 +
2*3^7 + 2*3^8 + 2*3^9 + 2*3^10 + 2*3^11 + 2*3^12 + 2*3^13 + 2*3^14 +
2*3^15 + 2*3^16 + 2*3^17 + 2*3^18 + 2*3^19 + 2*3^20 + O(3^21))
"""
if not (is_Berkovich_Cp(domain) or domain is None):
raise TypeError(
'domain must be a Berkovich space over Cp, not %s' % domain)
if isinstance(domain, Berkovich_Cp_Affine):
if not isinstance(dynamical_system, DynamicalSystem_affine):
try:
dynamical_system = DynamicalSystem_affine(dynamical_system)
except:
raise TypeError('domain was affine Berkovich space, but dynamical_system did not ' + \
'convert to an affine dynamical system')
if isinstance(domain, Berkovich_Cp_Projective):
if not isinstance(dynamical_system, DynamicalSystem_projective):
try:
dynamical_system = DynamicalSystem_projective(
dynamical_system)
except:
raise TypeError('domain was projective Berkovich space, but dynamical_system did not convert ' + \
'to a projective dynamical system')
if not isinstance(dynamical_system, DynamicalSystem):
try:
dynamical_system = DynamicalSystem(dynamical_system)
except:
raise TypeError(
'dynamical_system did not convert to a dynamical system')
morphism_domain = dynamical_system.domain()
if not isinstance(morphism_domain.base_ring(), pAdicBaseGeneric):
if morphism_domain.base_ring() in NumberFields():
if domain is None and ideal is not None:
if is_AffineSpace(morphism_domain):
domain = Berkovich_Cp_Affine(
morphism_domain.base_ring(), ideal)
else:
domain = Berkovich_Cp_Projective(
morphism_domain, ideal)
else:
if ideal is not None:
if ideal != domain.ideal():
raise ValueError(
'conflicting inputs for ideal and domain')
else:
raise ValueError('base ring of domain of dynamical_system must be p-adic or a number field ' + \
'not %s' %morphism_domain.base_ring())
if is_AffineSpace(morphism_domain):
return DynamicalSystem_Berkovich_affine(dynamical_system, domain)
return DynamicalSystem_Berkovich_projective(dynamical_system, domain)