Dynamical systems on affine schemes¶
An endomorphism of an affine scheme or subscheme determined by polynomials or rational functions.
The main constructor function is given by DynamicalSystem_affine
.
The constructor function can take polynomials, rational functions, 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.
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:
- David Kohel, William Stein
- Volker Braun (2011-08-08): Renamed classes, more documentation, misc cleanups.
- Ben Hutz (2017) relocate code and create new class
-
sage.dynamics.arithmetic_dynamics.affine_ds.
DynamicalSystem_affine
¶ An endomorphism of affine schemes determined by rational functions.
Warning
You should not create objects of this class directly because no type or consistency checking is performed. The preferred method to construct such dynamical systems is to use
DynamicalSystem_affine()
function.INPUT:
morphism_or_polys
– a SchemeMorphism, a polynomial, a rational function, or a list or tuple of polynomials or rational functionsdomain
– optional affine space or subscheme of such; the following combinations ofmorphism_or_polys
anddomain
are meaningful:morphism_or_polys
is a SchemeMorphism;domain
is ignored in this casemorphism_or_polys
is a list of polynomials or rational functions that define a rational endomorphism ofdomain
morphism_or_polys
is a list of polynomials or rational functions anddomain
is unspecified;domain
is then taken to be the affine space of appropriate dimension over the common base ring, if one exists, of the elements ofmorphism_or_polys
morphism_or_polys
is a single polynomial or rational function;domain
is ignored and assumed to be the 1-dimensional affine space over the base ring ofmorphism_or_polys
OUTPUT:
DynamicalSystem_affine
EXAMPLES:
sage: A3.<x,y,z> = AffineSpace(QQ, 3) sage: DynamicalSystem_affine([x, y, 1]) Dynamical System of Affine Space of dimension 3 over Rational Field Defn: Defined on coordinates by sending (x, y, z) to (x, y, 1)
sage: R.<x,y> = QQ[] sage: DynamicalSystem_affine([x/y, y^2 + 1]) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (x/y, y^2 + 1)
sage: R.<t> = ZZ[] sage: DynamicalSystem_affine(t^2 - 1) Dynamical System of Affine Space of dimension 1 over Integer Ring Defn: Defined on coordinates by sending (t) to (t^2 - 1)
sage: A.<x,y> = AffineSpace(QQ, 2) sage: X = A.subscheme([x-y^2]) sage: DynamicalSystem_affine([9/4*x^2, 3/2*y], domain=X) Dynamical System of Closed subscheme of Affine Space of dimension 2 over Rational Field defined by: -y^2 + x Defn: Defined on coordinates by sending (x, y) to (9/4*x^2, 3/2*y)
sage: A.<x,y> = AffineSpace(QQ, 2) sage: H = End(A) sage: f = H([x^2, y^2]) sage: DynamicalSystem_affine(f) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (x^2, y^2)
Notice that \(ZZ\) becomes \(QQ\) since the function is rational:
sage: A.<x,y> = AffineSpace(ZZ, 2) sage: DynamicalSystem_affine([3*x^2/(5*y), y^2/(2*x^2)]) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (3*x^2/(5*y), y^2/(2*x^2))
sage: A.<x,y> = AffineSpace(QQ, 2) sage: DynamicalSystem_affine([3/2*x^2, y^2]) Dynamical System of Affine Space of dimension 2 over Rational Field Defn: Defined on coordinates by sending (x, y) to (3/2*x^2, y^2)
If you pass in quotient ring elements, they are reduced:
sage: A.<x,y,z> = AffineSpace(QQ, 3) sage: X = A.subscheme([x-y]) sage: u,v,w = X.coordinate_ring().gens() sage: DynamicalSystem_affine([u, v, u+v], domain=X) Dynamical System of Closed subscheme of Affine Space of dimension 3 over Rational Field defined by: x - y Defn: Defined on coordinates by sending (x, y, z) to (y, y, 2*y)
sage: R.<t> = PolynomialRing(QQ) sage: A.<x,y,z> = AffineSpace(R, 3) sage: X = A.subscheme(x^2-y^2) sage: H = End(X) sage: f = H([x^2/(t*y), t*y^2, x*z]) sage: DynamicalSystem_affine(f) Dynamical System of Closed subscheme of Affine Space of dimension 3 over Univariate Polynomial Ring in t over Rational Field defined by: x^2 - y^2 Defn: Defined on coordinates by sending (x, y, z) to (x^2/(t*y), t*y^2, x*z)
sage: x = var('x') sage: DynamicalSystem_affine(x^2+1) Traceback (most recent call last): ... TypeError: Symbolic Ring cannot be the base ring
-
class
sage.dynamics.arithmetic_dynamics.affine_ds.
DynamicalSystem_affine_field
(polys_or_rat_fncts, domain)¶ Bases:
sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine
,sage.schemes.affine.affine_morphism.SchemeMorphism_polynomial_affine_space_field
-
weil_restriction
()¶ Compute the Weil restriction of this morphism over some extension field.
If the field is a finite field, then this computes the Weil restriction to the prime subfield.
A Weil restriction of scalars - denoted \(Res_{L/k}\) - is a functor which, for any finite extension of fields \(L/k\) and any algebraic variety \(X\) over \(L\), produces another corresponding variety \(Res_{L/k}(X)\), defined over \(k\). It is useful for reducing questions about varieties over large fields to questions about more complicated varieties over smaller fields. Since it is a functor it also applied to morphisms. In particular, the functor applied to a morphism gives the equivalent morphism from the Weil restriction of the domain to the Weil restriction of the codomain.
OUTPUT:
Scheme morphism on the Weil restrictions of the domain and codomain of the map.
EXAMPLES:
sage: K.<v> = QuadraticField(5) sage: A.<x,y> = AffineSpace(K, 2) sage: f = DynamicalSystem_affine([x^2-y^2, y^2]) sage: f.weil_restriction() Dynamical System of Affine Space of dimension 4 over Rational Field Defn: Defined on coordinates by sending (z0, z1, z2, z3) to (z0^2 + 5*z1^2 - z2^2 - 5*z3^2, 2*z0*z1 - 2*z2*z3, z2^2 + 5*z3^2, 2*z2*z3)
sage: K.<v> = QuadraticField(5) sage: PS.<x,y> = AffineSpace(K, 2) sage: f = DynamicalSystem_affine([x, y]) sage: F = f.weil_restriction() sage: P = PS(2, 1) sage: Q = P.weil_restriction() sage: f(P).weil_restriction() == F(Q) True
-
-
class
sage.dynamics.arithmetic_dynamics.affine_ds.
DynamicalSystem_affine_finite_field
(polys_or_rat_fncts, domain)¶ Bases:
sage.dynamics.arithmetic_dynamics.affine_ds.DynamicalSystem_affine_field
,sage.schemes.affine.affine_morphism.SchemeMorphism_polynomial_affine_space_finite_field
-
cyclegraph
()¶ Return the digraph of all orbits of this morphism mod \(p\).
For subschemes, only points on the subscheme whose image are also on the subscheme are in the digraph.
OUTPUT: a digraph
EXAMPLES:
sage: P.<x,y> = AffineSpace(GF(5), 2) sage: f = DynamicalSystem_affine([x^2-y, x*y+1]) sage: f.cyclegraph() Looped digraph on 25 vertices
sage: P.<x> = AffineSpace(GF(3^3, 't'), 1) sage: f = DynamicalSystem_affine([x^2-1]) sage: f.cyclegraph() Looped digraph on 27 vertices
sage: P.<x,y> = AffineSpace(GF(7), 2) sage: X = P.subscheme(x-y) sage: f = DynamicalSystem_affine([x^2, y^2], domain=X) sage: f.cyclegraph() Looped digraph on 7 vertices
-
orbit_structure
(P)¶ Every point is preperiodic over a finite field.
This function returns the pair \([m,n]\) where \(m\) is the preperiod and \(n\) is the period of the point
P
by this map.INPUT:
P
– a point in the map’s domain
OUTPUT: a list \([m, n]\) of integers
EXAMPLES:
sage: A.<x,y> = AffineSpace(GF(13), 2) sage: f = DynamicalSystem_affine([x^2 - 1, y^2]) sage: f.orbit_structure(A(2, 3)) [1, 6]
sage: A.<x,y,z> = AffineSpace(GF(49, 't'), 3) sage: f = DynamicalSystem_affine([x^2 - z, x - y + z, y^2 - x^2]) sage: f.orbit_structure(A(1, 1, 2)) [7, 6]
-