Dynamical systems for products of projective spaces - Discrete dynamics

Skip to content
Back to top
View this page
Edit this page

# 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

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

Python

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

  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

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

  Python

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

    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` – positive integer

    - `normalize` – boolean (default: `False`)

    OUTPUT: a point in `self.codomain()`

    EXAMPLES:

    Sage

        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)

    Python

        >>> 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

        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)

    [Python]

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

    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

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

    Python

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

    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` – 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

        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)]

    Python

        >>> 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

        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)]

    [Python]

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

  Bases: `DynamicalSystem_product_projective`

class sage.dynamics.arithmetic_dynamics.product_projective_ds.DynamicalSystem_product_projective_finite_field(polys, domain)

  Bases: `DynamicalSystem_product_projective_field`

  cyclegraph()

    Return the digraph of all orbits of this morphism mod \(p\).

    OUTPUT: a digraph

    EXAMPLES:

    Sage

        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

    Python

        >>> 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

        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

    [Python]

        >>> 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

        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

    Python

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