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 – a 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 P by this dynamical system.

If normalize is 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 – a positive integer

  • normalize – (default: False) boolean

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 – 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).

>>> 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 normalize is True. Perform the checks on point initialize if check is True.

INPUT:

  • P – a point in self.domain()

  • N – a non-negative integer or list or tuple of two non-negative integers

kwds:

  • check – (default: True) boolean

  • normalize – (default: False) boolean

OUTPUT: a 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]#

Bases: DynamicalSystem_product_projective

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.