Generic dynamical systems on schemes¶
This is the generic class for dynamical systems and contains the exported constructor functions. The constructor functions can take either polynomials (or rational functions in the affine case) or morphisms from which to construct a dynamical system. If the domain is not specified, it is constructed. However, if you plan on working with points or subvarieties in the domain, it recommended to specify the domain. For products of projective spaces the domain must be specified.
The initialization checks are always performed by the constructor functions. It is possible, but not recommended, to skip these checks by calling the class initialization directly.
AUTHORS:
- Ben Hutz (July 2017): initial version
-
class
sage.dynamics.arithmetic_dynamics.generic_ds.
DynamicalSystem
(polys_or_rat_fncts, domain)¶ Bases:
sage.schemes.generic.morphism.SchemeMorphism_polynomial
Base class for dynamical systems of schemes.
INPUT:
polys_or_rat_fncts
– a list of polynomials or rational functions, all of which should have the same parentdomain
– an affine or projective scheme, or product of projective schemes, on whichpolys
defines an endomorphism. Subschemes are also oknames
– (default:('X', 'Y')
) tuple of strings to be used as coordinate names for a projective space that is constructedThe following combinations of
morphism_or_polys
anddomain
are meaningful:morphism_or_polys
is a SchemeMorphism;domain
is ignored in this casemorphism_or_polys
is a list of homogeneous polynomials that define a rational endomorphism ofdomain
morphism_or_polys
is a list of homogeneous polynomials anddomain
is unspecified;domain
is then taken to be the projective space of appropriate dimension over the base ring of the first element ofmorphism_or_polys
morphism_or_polys
is a single polynomial or rational function;domain
is ignored and taken to be a 1-dimensional projective space over the base ring ofmorphism_or_polys
with coordinate names given bynames
EXAMPLES:
sage: A.<x> = AffineSpace(QQ,1) sage: f = DynamicalSystem_affine([x^2+1]) sage: type(f) <class 'sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine_field'>
sage: P.<x,y> = ProjectiveSpace(QQ,1) sage: f = DynamicalSystem_projective([x^2+y^2, y^2]) sage: type(f) <class 'sage.dynamics.arithmetic_dynamics.projective_ds.DynamicalSystem_projective_field'>
sage: P1.<x,y> = ProjectiveSpace(CC,1) sage: H = End(P1) sage: DynamicalSystem(H([y, x])) Dynamical System of Projective Space of dimension 1 over Complex Field with 53 bits of precision Defn: Defined on coordinates by sending (x : y) to (y : x)
DynamicalSystem
defaults to projective:sage: R.<x,y,z> = QQ[] sage: DynamicalSystem([x^2, y^2, z^2]) Dynamical System of Projective Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x : y : z) to (x^2 : y^2 : z^2)
sage: A.<x,y> = AffineSpace(QQ, 2) sage: DynamicalSystem([y, x], domain=A) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (y, x) sage: H = End(A) sage: DynamicalSystem(H([y, x])) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (y, x)
-
as_scheme_morphism
()¶ Return this dynamical system as
SchemeMorphism_polynomial
.OUTPUT:
SchemeMorphism_polynomial
EXAMPLES:
sage: P.<x,y,z> = ProjectiveSpace(ZZ, 2) sage: f = DynamicalSystem_projective([x^2, y^2, z^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.projective.projective_morphism.SchemeMorphism_polynomial_projective_space'>
sage: P.<x,y> = ProjectiveSpace(QQ, 1) sage: f = DynamicalSystem_projective([x^2-y^2, y^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.projective.projective_morphism.SchemeMorphism_polynomial_projective_space_field'>
sage: P.<x,y> = ProjectiveSpace(GF(5), 1) sage: f = DynamicalSystem_projective([x^2, y^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.projective.projective_morphism.SchemeMorphism_polynomial_projective_space_finite_field'>
sage: A.<x,y> = AffineSpace(ZZ, 2) sage: f = DynamicalSystem_affine([x^2-2, y^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.affine.affine_morphism.SchemeMorphism_polynomial_affine_space'>
sage: A.<x,y> = AffineSpace(QQ, 2) sage: f = DynamicalSystem_affine([x^2-2, y^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.affine.affine_morphism.SchemeMorphism_polynomial_affine_space_field'>
sage: A.<x,y> = AffineSpace(GF(3), 2) sage: f = DynamicalSystem_affine([x^2-2, y^2]) sage: type(f.as_scheme_morphism()) <class 'sage.schemes.affine.affine_morphism.SchemeMorphism_polynomial_affine_space_finite_field'>
-
change_ring
(R, check=True)¶ Return a new dynamical system which is this map coerced to
R
.If
check
isTrue
, then the initialization checks are performed.INPUT:
R
– ring or morphism
OUTPUT:
A new
DynamicalSystem_projective
that is this map coerced toR
.EXAMPLES:
sage: P.<x,y> = ProjectiveSpace(ZZ, 1) sage: f = DynamicalSystem_projective([3*x^2, y^2]) sage: f.change_ring(GF(5)) Dynamical System of Projective Space of dimension 1 over Finite Field of size 5 Defn: Defined on coordinates by sending (x : y) to (-2*x^2 : y^2)
-
specialization
(D=None, phi=None, homset=None)¶ Specialization of this dynamical system.
Given a family of maps defined over a polynomial ring. A specialization is a particular member of that family. The specialization can be specified either by a dictionary or a
SpecializationMorphism
.INPUT:
D
– (optional) dictionaryphi
– (optional) SpecializationMorphismhomset
– (optional) homset of specialized map
OUTPUT:
DynamicalSystem
EXAMPLES:
sage: R.<c> = PolynomialRing(QQ) sage: P.<x,y> = ProjectiveSpace(R, 1) sage: f = DynamicalSystem_projective([x^2 + c*y^2,y^2], domain=P) sage: f.specialization({c:1}) Dynamical System of Projective Space of dimension 1 over Rational Field Defn: Defined on coordinates by sending (x : y) to (x^2 + y^2 : y^2)