Dynamical systems for products of projective spaces¶
This class builds on the product projective space class.
The main constructor functions are given by DynamicalSystem and
DynamicalSystem_projective. The constructors function can take either
polynomials or a morphism from which to construct a dynamical system.
The must be specified.
EXAMPLES:
sage: P1xP1.<x,y,u,v> = ProductProjectiveSpaces(QQ, [1, 1])
sage: DynamicalSystem_projective([x^2*u, y^2*v, x*v^2, y*u^2], domain=P1xP1)
Dynamical System of Product of projective spaces P^1 x P^1 over Rational Field
  Defn: Defined by sending (x : y , u : v) to
        (x^2*u : y^2*v , x*v^2 : y*u^2).
>>> from sage.all import *
>>> P1xP1 = ProductProjectiveSpaces(QQ, [Integer(1), Integer(1)], names=('x', 'y', 'u', 'v',)); (x, y, u, v,) = P1xP1._first_ngens(4)
>>> DynamicalSystem_projective([x**Integer(2)*u, y**Integer(2)*v, x*v**Integer(2), y*u**Integer(2)], domain=P1xP1)
Dynamical System of Product of projective spaces P^1 x P^1 over Rational Field
  Defn: Defined by sending (x : y , u : v) to
        (x^2*u : y^2*v , x*v^2 : y*u^2).
- class sage.dynamics.arithmetic_dynamics.product_projective_ds.DynamicalSystem_product_projective(polys, domain)[source]¶
- Bases: - DynamicalSystem,- ProductProjectiveSpaces_morphism_ring- The class of dynamical systems on products of projective spaces. - 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_projective()function.- INPUT: - polys– list of \(n_1 + \cdots + n_r\) multi-homogeneous polynomials, all of which should have the same parent
- domain– a projective scheme embedded in \(P^{n_1-1} \times \cdots \times P^{n_r-1}\)
 - EXAMPLES: - sage: T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ) sage: DynamicalSystem_projective([x^2, y^2, z^2, w^2, u^2], domain=T) Dynamical System of Product of projective spaces P^2 x P^1 over Rational Field Defn: Defined by sending (x : y : z , w : u) to (x^2 : y^2 : z^2 , w^2 : u^2). - >>> from sage.all import * >>> T = ProductProjectiveSpaces([Integer(2), Integer(1)], QQ, names=('x', 'y', 'z', 'w', 'u',)); (x, y, z, w, u,) = T._first_ngens(5) >>> DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2), w**Integer(2), u**Integer(2)], domain=T) Dynamical System of Product of projective spaces P^2 x P^1 over Rational Field Defn: Defined by sending (x : y : z , w : u) to (x^2 : y^2 : z^2 , w^2 : u^2). - nth_iterate(P, n, normalize=False)[source]¶
- Return the - n-th iterate of- Pby this dynamical system.- If - normalizeis- True, then the coordinates are automatically normalized.- Todo - Is there a more efficient way to do this? - INPUT: - P– a point in- self.domain()
- n– positive integer
- normalize– boolean (default:- False)
 - OUTPUT: a point in - self.codomain()- EXAMPLES: - sage: Z.<a,b,x,y,z> = ProductProjectiveSpaces([1, 2], QQ) sage: f = DynamicalSystem_projective([a^3, b^3 + a*b^2, x^2, y^2 - z^2, z*y], ....: domain=Z) sage: P = Z([1, 1, 1, 1, 1]) sage: f.nth_iterate(P, 3) (1/1872 : 1 , 1 : 1 : 0) - >>> from sage.all import * >>> Z = ProductProjectiveSpaces([Integer(1), Integer(2)], QQ, names=('a', 'b', 'x', 'y', 'z',)); (a, b, x, y, z,) = Z._first_ngens(5) >>> f = DynamicalSystem_projective([a**Integer(3), b**Integer(3) + a*b**Integer(2), x**Integer(2), y**Integer(2) - z**Integer(2), z*y], ... domain=Z) >>> P = Z([Integer(1), Integer(1), Integer(1), Integer(1), Integer(1)]) >>> f.nth_iterate(P, Integer(3)) (1/1872 : 1 , 1 : 1 : 0) - sage: Z.<a,b,x,y> = ProductProjectiveSpaces([1, 1], ZZ) sage: f = DynamicalSystem_projective([a*b, b^2, x^3 - y^3, y^2*x], domain=Z) sage: P = Z([2, 6, 2, 4]) sage: f.nth_iterate(P, 2, normalize=True) (1 : 3 , 407 : 112) - >>> from sage.all import * >>> Z = ProductProjectiveSpaces([Integer(1), Integer(1)], ZZ, names=('a', 'b', 'x', 'y',)); (a, b, x, y,) = Z._first_ngens(4) >>> f = DynamicalSystem_projective([a*b, b**Integer(2), x**Integer(3) - y**Integer(3), y**Integer(2)*x], domain=Z) >>> P = Z([Integer(2), Integer(6), Integer(2), Integer(4)]) >>> f.nth_iterate(P, Integer(2), normalize=True) (1 : 3 , 407 : 112) 
 - nth_iterate_map(n)[source]¶
- Return the - n-th iterate of this dynamical system.- ALGORITHM: - Uses a form of successive squaring to reduce computations. - Todo - This could be improved. - INPUT: - n– 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). - >>> from sage.all import * >>> Z = ProductProjectiveSpaces([Integer(1) , Integer(2)], QQ, names=('a', 'b', 'x', 'y', 'z',)); (a, b, x, y, z,) = Z._first_ngens(5) >>> f = DynamicalSystem_projective([a**Integer(3), b**Integer(3), x**Integer(2), y**Integer(2), z**Integer(2)], domain=Z) >>> f.nth_iterate_map(Integer(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). 
 - orbit(P, N, **kwds)[source]¶
- Return the orbit of \(P\) by this dynamical system. - Let \(F\) be this dynamical system. If \(N\) is an integer return \([P,F(P),\ldots,F^N(P)]\). - If \(N\) is a list or tuple \(N = [m, k]\) return \([F^m(P),\ldots,F^k(P)]\). Automatically normalize the points if - normalizeis- True. Perform the checks on point initialize if- checkis- True.- INPUT: - P– a point in- self.domain()
- N– nonnegative integer or list or tuple of two nonnegative integers
 - kwds: - check– boolean (default:- True)
- normalize– boolean (default:- False)
 - OUTPUT: list of points in - self.codomain()- EXAMPLES: - sage: Z.<a,b,x,y,z> = ProductProjectiveSpaces([1, 2], QQ) sage: f = DynamicalSystem_projective([a^3, b^3 + a*b^2, x^2, y^2 - z^2, z*y], ....: domain=Z) sage: P = Z([1, 1, 1, 1, 1]) sage: f.orbit(P, 3) [(1 : 1 , 1 : 1 : 1), (1/2 : 1 , 1 : 0 : 1), (1/12 : 1 , -1 : 1 : 0), (1/1872 : 1 , 1 : 1 : 0)] - >>> from sage.all import * >>> Z = ProductProjectiveSpaces([Integer(1), Integer(2)], QQ, names=('a', 'b', 'x', 'y', 'z',)); (a, b, x, y, z,) = Z._first_ngens(5) >>> f = DynamicalSystem_projective([a**Integer(3), b**Integer(3) + a*b**Integer(2), x**Integer(2), y**Integer(2) - z**Integer(2), z*y], ... domain=Z) >>> P = Z([Integer(1), Integer(1), Integer(1), Integer(1), Integer(1)]) >>> f.orbit(P, Integer(3)) [(1 : 1 , 1 : 1 : 1), (1/2 : 1 , 1 : 0 : 1), (1/12 : 1 , -1 : 1 : 0), (1/1872 : 1 , 1 : 1 : 0)] - sage: Z.<a,b,x,y> = ProductProjectiveSpaces([1, 1], ZZ) sage: f = DynamicalSystem_projective([a*b, b^2, x^3 - y^3, y^2*x], domain=Z) sage: P = Z([2, 6, 2, 4]) sage: f.orbit(P, 3, normalize=True) [(1 : 3 , 1 : 2), (1 : 3 , -7 : 4), (1 : 3 , 407 : 112), (1 : 3 , 66014215 : 5105408)] - >>> from sage.all import * >>> Z = ProductProjectiveSpaces([Integer(1), Integer(1)], ZZ, names=('a', 'b', 'x', 'y',)); (a, b, x, y,) = Z._first_ngens(4) >>> f = DynamicalSystem_projective([a*b, b**Integer(2), x**Integer(3) - y**Integer(3), y**Integer(2)*x], domain=Z) >>> P = Z([Integer(2), Integer(6), Integer(2), Integer(4)]) >>> f.orbit(P, Integer(3), normalize=True) [(1 : 3 , 1 : 2), (1 : 3 , -7 : 4), (1 : 3 , 407 : 112), (1 : 3 , 66014215 : 5105408)] 
 
- class sage.dynamics.arithmetic_dynamics.product_projective_ds.DynamicalSystem_product_projective_field(polys, domain)[source]¶
- class sage.dynamics.arithmetic_dynamics.product_projective_ds.DynamicalSystem_product_projective_finite_field(polys, domain)[source]¶
- Bases: - DynamicalSystem_product_projective_field- cyclegraph()[source]¶
- Return the digraph of all orbits of this morphism mod \(p\). - OUTPUT: a digraph - EXAMPLES: - sage: P.<a,b,c,d> = ProductProjectiveSpaces(GF(3), [1,1]) sage: f = DynamicalSystem_projective([a^2, b^2, c^2, d^2], domain=P) sage: f.cyclegraph() # needs sage.graphs Looped digraph on 16 vertices - >>> from sage.all import * >>> P = ProductProjectiveSpaces(GF(Integer(3)), [Integer(1),Integer(1)], names=('a', 'b', 'c', 'd',)); (a, b, c, d,) = P._first_ngens(4) >>> f = DynamicalSystem_projective([a**Integer(2), b**Integer(2), c**Integer(2), d**Integer(2)], domain=P) >>> f.cyclegraph() # needs sage.graphs Looped digraph on 16 vertices - sage: P.<a,b,c,d> = ProductProjectiveSpaces(GF(5), [1,1]) sage: f = DynamicalSystem_projective([a^2, b^2, c, d], domain=P) sage: f.cyclegraph() # needs sage.graphs Looped digraph on 36 vertices - >>> from sage.all import * >>> P = ProductProjectiveSpaces(GF(Integer(5)), [Integer(1),Integer(1)], names=('a', 'b', 'c', 'd',)); (a, b, c, d,) = P._first_ngens(4) >>> f = DynamicalSystem_projective([a**Integer(2), b**Integer(2), c, d], domain=P) >>> f.cyclegraph() # needs sage.graphs Looped digraph on 36 vertices - sage: P.<a,b,c,d,e> = ProductProjectiveSpaces(GF(2), [1,2]) sage: f = DynamicalSystem_projective([a^2, b^2, c, d, e], domain=P) sage: f.cyclegraph() # needs sage.graphs Looped digraph on 21 vertices - >>> from sage.all import * >>> P = ProductProjectiveSpaces(GF(Integer(2)), [Integer(1),Integer(2)], names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = P._first_ngens(5) >>> f = DynamicalSystem_projective([a**Integer(2), b**Integer(2), c, d, e], domain=P) >>> f.cyclegraph() # needs sage.graphs Looped digraph on 21 vertices - Todo - Dynamical systems for subschemes of product projective spaces needs work. Thus this is not implemented for subschemes.