Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
r""" Dynamical systems for products of projective spaces
This class builds on the prouct 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). """ #***************************************************************************** # Copyright (C) 2014 Ben Hutz <bn4941@gmail.com> # # Distributed under the terms of the GNU General Public License (GPL) # as published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # http://www.gnu.org/licenses/ #*****************************************************************************
ProductProjectiveSpaces_morphism_ring): r""" 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 :func:`~sage.dynamics.arithmetic_dynamics.generic_ds.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). """
r""" The Python constructor.
See :class:`DynamicalSystem` for details.
EXAMPLES::
sage: T.<x,y,w,u> = ProductProjectiveSpaces([1, 1], QQ) sage: DynamicalSystem_projective([x^2, y^2, w^2, u^2], domain=T) Dynamical System of Product of projective spaces P^1 x P^1 over Rational Field Defn: Defined by sending (x : y , w : u) to (x^2 : y^2 , w^2 : u^2). """
r""" Make dynamical systems of products of projective spaces callable.
INPUT:
- ``P`` -- a point in the domain
- ``check`` -- Boolean - whether or not to perform the input checks on the image point (Default: ``True``)
OUTPUT: The image point in the codomain
EXAMPLES::
sage: T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ) sage: F = DynamicalSystem_projective([x^2*u, y^2*w, z^2*u, w^2, u^2], domain=T) sage: F(T([2, 1, 3, 0, 1])) (4/9 : 0 : 1 , 0 : 1) """ if check: from sage.schemes.product_projective.point import ProductProjectiveSpaces_point_ring if not isinstance(P, ProductProjectiveSpaces_point_ring): try: P = self.domain()(P) except (TypeError, NotImplementedError): raise TypeError("%s fails to convert into the map's domain %s, but a `pushforward` method is not properly implemented"%(P, self.domain())) elif self.domain()!= P.codomain(): raise TypeError("%s fails to convert into the map's domain %s, but a `pushforward` method is not properly implemented"%(P, self.domain()))
A = self.domain() Q = list(P) newP = [f(Q) for f in self.defining_polynomials()] return(A.point(newP, check))
r""" 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)
::
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) """ raise TypeError("point is not defined over domain of function") raise TypeError("must be a forward orbit") return(self) else:
r""" 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 == True``. Perform the checks on point initialize if ``check==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)]
::
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)] """ raise TypeError("point is not defined over domain of function") except TypeError: raise TypeError("orbit bounds must be integers") raise TypeError("orbit bounds must be non-negative") return([])
Q = self(Q, check) if normalize == True: Q.normalize_coordinates()
r""" Return the nth 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). """ raise TypeError("iterate number must be a nonnegative integer") PHI = [gen.lift() for gen in Coord_ring.gens()] else:
|