Dynamical systems on projective schemes

A dynamical system of projective schemes determined by homogeneous polynomials functions that define what the morphism does on points in the ambient projective space.

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

  • William Stein (2006-02-11): fixed bug where P(0,0,0) was allowed as a projective point.

  • Volker Braun (2011-08-08): Renamed classes, more documentation, misc cleanups.

  • Ben Hutz (2013-03) iteration functionality and new directory structure for affine/projective, height functionality

  • Brian Stout, Ben Hutz (Nov 2013) - added minimal model functionality

  • Dillon Rose (2014-01): Speed enhancements

  • Ben Hutz (2015-11): iteration of subschemes

  • Ben Hutz (2017-7): relocate code and create class

class sage.dynamics.arithmetic_dynamics.projective_ds.DynamicalSystem_projective(polys, domain)[source]

Bases: SchemeMorphism_polynomial_projective_space, DynamicalSystem

A dynamical system of projective schemes determined by homogeneous polynomials that define what the morphism does on points in the ambient projective space.

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:

  • morphism_or_polys – a SchemeMorphism, a polynomial, a rational function, or a list or tuple of homogeneous polynomials

  • domain – (optional) projective space or projective subscheme

  • names – tuple of strings (default: 'X','Y') to be used as coordinate names for a projective space that is constructed

    The following combinations of morphism_or_polys and domain are meaningful:

    • morphism_or_polys is a SchemeMorphism; domain is ignored in this case.

    • morphism_or_polys is a list of homogeneous polynomials that define a rational endomorphism of domain.

    • morphism_or_polys is a list of homogeneous polynomials and domain is unspecified; domain is then taken to be the projective space of appropriate dimension over the common base ring, if one exists, of the elements of morphism_or_polys.

    • morphism_or_polys is a single polynomial or rational function; domain is ignored and taken to be a 1-dimensional projective space over the base ring of morphism_or_polys with coordinate names given by names.

OUTPUT: DynamicalSystem_projective

EXAMPLES:

sage: P1.<x,y> = ProjectiveSpace(QQ,1)
sage: DynamicalSystem_projective([y, 2*x])
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (y : 2*x)

>>> from sage.all import *
>>> P1 = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P1._first_ngens(2)
>>> DynamicalSystem_projective([y, Integer(2)*x])
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (y : 2*x)

P1.<x,y> = ProjectiveSpace(QQ,1)
DynamicalSystem_projective([y, 2*x])

We can define dynamical systems on \(P^1\) by giving a polynomial or rational function:

sage: R.<t> = QQ[]
sage: DynamicalSystem_projective(t^2 - 3)
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 - 3*Y^2 : Y^2)
sage: DynamicalSystem_projective(1/t^2)
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (Y^2 : X^2)

>>> from sage.all import *
>>> R = QQ['t']; (t,) = R._first_ngens(1)
>>> DynamicalSystem_projective(t**Integer(2) - Integer(3))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 - 3*Y^2 : Y^2)
>>> DynamicalSystem_projective(Integer(1)/t**Integer(2))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (Y^2 : X^2)

R.<t> = QQ[]
DynamicalSystem_projective(t^2 - 3)
DynamicalSystem_projective(1/t^2)
sage: R.<x> = PolynomialRing(QQ,1)
sage: DynamicalSystem_projective(x^2, names=['a','b'])
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (a : b) to
        (a^2 : b^2)

>>> from sage.all import *
>>> R = PolynomialRing(QQ,Integer(1), names=('x',)); (x,) = R._first_ngens(1)
>>> DynamicalSystem_projective(x**Integer(2), names=['a','b'])
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (a : b) to
        (a^2 : b^2)

R.<x> = PolynomialRing(QQ,1)
DynamicalSystem_projective(x^2, names=['a','b'])
>>> from sage.all import *
>>> R = PolynomialRing(QQ,Integer(1), names=('x',)); (x,) = R._first_ngens(1)
>>> DynamicalSystem_projective(x**Integer(2), names=['a','b'])
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (a : b) to
        (a^2 : b^2)

R.<x> = PolynomialRing(QQ,1)
DynamicalSystem_projective(x^2, names=['a','b'])

Symbolic Ring elements are not allowed:

sage: x,y = var('x,y')                                                          # needs sage.symbolic
sage: DynamicalSystem_projective([x^2, y^2])                                    # needs sage.symbolic
Traceback (most recent call last):
...
ValueError: [x^2, y^2] must be elements of a polynomial ring

>>> from sage.all import *
>>> x,y = var('x,y')                                                          # needs sage.symbolic
>>> DynamicalSystem_projective([x**Integer(2), y**Integer(2)])                                    # needs sage.symbolic
Traceback (most recent call last):
...
ValueError: [x^2, y^2] must be elements of a polynomial ring

x,y = var('x,y')                                                          # needs sage.symbolic
DynamicalSystem_projective([x^2, y^2])                                    # needs sage.symbolic
sage: R.<x> = PolynomialRing(QQ,1)
sage: DynamicalSystem_projective(x^2)
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 : Y^2)

>>> from sage.all import *
>>> R = PolynomialRing(QQ,Integer(1), names=('x',)); (x,) = R._first_ngens(1)
>>> DynamicalSystem_projective(x**Integer(2))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 : Y^2)

R.<x> = PolynomialRing(QQ,1)
DynamicalSystem_projective(x^2)
>>> from sage.all import *
>>> R = PolynomialRing(QQ,Integer(1), names=('x',)); (x,) = R._first_ngens(1)
>>> DynamicalSystem_projective(x**Integer(2))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 : Y^2)

R.<x> = PolynomialRing(QQ,1)
DynamicalSystem_projective(x^2)
sage: R.<t> = PolynomialRing(QQ)
sage: P.<x,y,z> = ProjectiveSpace(R, 2)
sage: X = P.subscheme([x])
sage: DynamicalSystem_projective([x^2, t*y^2, x*z], domain=X)
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Univariate Polynomial Ring in t over Rational Field defined by:
  x
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 : t*y^2 : x*z)

>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme([x])
>>> DynamicalSystem_projective([x**Integer(2), t*y**Integer(2), x*z], domain=X)
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Univariate Polynomial Ring in t over Rational Field defined by:
  x
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 : t*y^2 : x*z)

R.<t> = PolynomialRing(QQ)
P.<x,y,z> = ProjectiveSpace(R, 2)
X = P.subscheme([x])
DynamicalSystem_projective([x^2, t*y^2, x*z], domain=X)
>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme([x])
>>> DynamicalSystem_projective([x**Integer(2), t*y**Integer(2), x*z], domain=X)
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Univariate Polynomial Ring in t over Rational Field defined by:
  x
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 : t*y^2 : x*z)

R.<t> = PolynomialRing(QQ)
P.<x,y,z> = ProjectiveSpace(R, 2)
X = P.subscheme([x])
DynamicalSystem_projective([x^2, t*y^2, x*z], domain=X)

When elements of the quotient ring are used, they are reduced:

sage: P.<x,y,z> = ProjectiveSpace(CC, 2)
sage: X = P.subscheme([x - y])
sage: u,v,w = X.coordinate_ring().gens()                                        # needs sage.rings.function_field
sage: DynamicalSystem_projective([u^2, v^2, w*u], domain=X)                     # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Complex Field with 53 bits of precision defined by:
  x - y
  Defn: Defined on coordinates by sending (x : y : z) to
        (y^2 : y^2 : y*z)

>>> from sage.all import *
>>> P = ProjectiveSpace(CC, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme([x - y])
>>> u,v,w = X.coordinate_ring().gens()                                        # needs sage.rings.function_field
>>> DynamicalSystem_projective([u**Integer(2), v**Integer(2), w*u], domain=X)                     # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Complex Field with 53 bits of precision defined by:
  x - y
  Defn: Defined on coordinates by sending (x : y : z) to
        (y^2 : y^2 : y*z)

P.<x,y,z> = ProjectiveSpace(CC, 2)
X = P.subscheme([x - y])
u,v,w = X.coordinate_ring().gens()                                        # needs sage.rings.function_field
DynamicalSystem_projective([u^2, v^2, w*u], domain=X)                     # needs sage.rings.function_field

We can also compute the forward image of subschemes through elimination. In particular, let \(X = V(h_1,\ldots, h_t)\) and define the ideal \(I = (h_1,\ldots,h_t,y_0-f_0(\bar{x}), \ldots, y_n-f_n(\bar{x}))\). Then the elimination ideal \(I_{n+1} = I \cap K[y_0,\ldots,y_n]\) is a homogeneous ideal and \(f(X) = V(I_{n+1})\):

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([(x-2*y)^2, (x-2*z)^2, x^2])
sage: X = P.subscheme(y - z)
sage: f(f(f(X)))                                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  y - z

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([(x-Integer(2)*y)**Integer(2), (x-Integer(2)*z)**Integer(2), x**Integer(2)])
>>> X = P.subscheme(y - z)
>>> f(f(f(X)))                                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  y - z

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([(x-2*y)^2, (x-2*z)^2, x^2])
X = P.subscheme(y - z)
f(f(f(X)))                                                                # needs sage.rings.function_field
sage: P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
sage: f = DynamicalSystem_projective([(x-2*y)^2, (x-2*z)^2, (x-2*w)^2, x^2])
sage: f(P.subscheme([x, y, z]))                                                 # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 3 over Rational Field
defined by:
  w,
  y,
  x

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([(x-Integer(2)*y)**Integer(2), (x-Integer(2)*z)**Integer(2), (x-Integer(2)*w)**Integer(2), x**Integer(2)])
>>> f(P.subscheme([x, y, z]))                                                 # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 3 over Rational Field
defined by:
  w,
  y,
  x

P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
f = DynamicalSystem_projective([(x-2*y)^2, (x-2*z)^2, (x-2*w)^2, x^2])
f(P.subscheme([x, y, z]))                                                 # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([(x-Integer(2)*y)**Integer(2), (x-Integer(2)*z)**Integer(2), (x-Integer(2)*w)**Integer(2), x**Integer(2)])
>>> f(P.subscheme([x, y, z]))                                                 # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 3 over Rational Field
defined by:
  w,
  y,
  x

P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
f = DynamicalSystem_projective([(x-2*y)^2, (x-2*z)^2, (x-2*w)^2, x^2])
f(P.subscheme([x, y, z]))                                                 # needs sage.rings.function_field
sage: T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ)
sage: DynamicalSystem_projective([x^2*u, y^2*w, z^2*u, 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*u : y^2*w : z^2*u , 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)*u, y**Integer(2)*w, z**Integer(2)*u, 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*u : y^2*w : z^2*u , w^2 : u^2).

T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ)
DynamicalSystem_projective([x^2*u, y^2*w, z^2*u, w^2, u^2], domain=T)
>>> 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)*u, y**Integer(2)*w, z**Integer(2)*u, 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*u : y^2*w : z^2*u , w^2 : u^2).

T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ)
DynamicalSystem_projective([x^2*u, y^2*w, z^2*u, w^2, u^2], domain=T)
sage: # needs sage.rings.number_field
sage: K.<v> = QuadraticField(-7)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem([x^3 + v*x*y^2, y^3])
sage: fbar = f.change_ring(QQbar)
sage: fbar.is_postcritically_finite()
False

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(7), names=('v',)); (v,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(3) + v*x*y**Integer(2), y**Integer(3)])
>>> fbar = f.change_ring(QQbar)
>>> fbar.is_postcritically_finite()
False

# needs sage.rings.number_field
K.<v> = QuadraticField(-7)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem([x^3 + v*x*y^2, y^3])
fbar = f.change_ring(QQbar)
fbar.is_postcritically_finite()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(7), names=('v',)); (v,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(3) + v*x*y**Integer(2), y**Integer(3)])
>>> fbar = f.change_ring(QQbar)
>>> fbar.is_postcritically_finite()
False

# needs sage.rings.number_field
K.<v> = QuadraticField(-7)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem([x^3 + v*x*y^2, y^3])
fbar = f.change_ring(QQbar)
fbar.is_postcritically_finite()
Lattes_to_curve(return_conjugation=False, check_lattes=False)[source]

Finds a Short Weierstrass Model Elliptic curve of self self assumed to be Lattes map and not in charateristic 2 or 3

INPUT:

\(return_conjugation`\) – (default: False) if True, then return the conjugation that moves self to a map that comes from a Short Weierstrass Model Elliptic curve \(check_lattes`\).-.(default:.``False``) if True, then will ValueError if not Lattes

OUTPUT: a Short Weierstrass Model Elliptic curve which is isogenous to the Elliptic curve of ‘self’, If return_conjugation is True then also returns conjugation of ‘self’ to short form as a matrix

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = P.Lattes_map(EllipticCurve([0, 0, 0, 10, 2]), 2)
sage: f.Lattes_to_curve()
Elliptic Curve defined by y^2 = x^3 + 10*x + 2 over Rational Field

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = P.Lattes_map(EllipticCurve([Integer(0), Integer(0), Integer(0), Integer(10), Integer(2)]), Integer(2))
>>> f.Lattes_to_curve()
Elliptic Curve defined by y^2 = x^3 + 10*x + 2 over Rational Field

P.<x,y> = ProjectiveSpace(QQ, 1)
f = P.Lattes_map(EllipticCurve([0, 0, 0, 10, 2]), 2)
f.Lattes_to_curve()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: M = matrix(QQ,2,2,[[1,2],[-1,2]])
sage: f = P.Lattes_map(EllipticCurve([1, 1, 1, 1, 2]), 2)
sage: f = f.conjugate(M)
sage: f.Lattes_to_curve(return_conjugation = True)
(
[  -7/36*a^2 + 7/12*a + 7/3 -17/18*a^2 + 17/6*a + 34/3]
[    -1/8*a^2 + 1/4*a + 3/2        1/4*a^2 - 1/2*a - 3],
Elliptic Curve defined by y^2 = x^3 + (-94/27*a^2+94/9*a+376/9)*x +
12232/243 over Number Field in a with defining polynomial y^3 - 18*y - 30
)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1),Integer(2)],[-Integer(1),Integer(2)]])
>>> f = P.Lattes_map(EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(1), Integer(2)]), Integer(2))
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[  -7/36*a^2 + 7/12*a + 7/3 -17/18*a^2 + 17/6*a + 34/3]
[    -1/8*a^2 + 1/4*a + 3/2        1/4*a^2 - 1/2*a - 3],
Elliptic Curve defined by y^2 = x^3 + (-94/27*a^2+94/9*a+376/9)*x +
12232/243 over Number Field in a with defining polynomial y^3 - 18*y - 30
)

P.<x,y> = ProjectiveSpace(QQ, 1)
M = matrix(QQ,2,2,[[1,2],[-1,2]])
f = P.Lattes_map(EllipticCurve([1, 1, 1, 1, 2]), 2)
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1),Integer(2)],[-Integer(1),Integer(2)]])
>>> f = P.Lattes_map(EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(1), Integer(2)]), Integer(2))
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[  -7/36*a^2 + 7/12*a + 7/3 -17/18*a^2 + 17/6*a + 34/3]
[    -1/8*a^2 + 1/4*a + 3/2        1/4*a^2 - 1/2*a - 3],
Elliptic Curve defined by y^2 = x^3 + (-94/27*a^2+94/9*a+376/9)*x +
12232/243 over Number Field in a with defining polynomial y^3 - 18*y - 30
)

P.<x,y> = ProjectiveSpace(QQ, 1)
M = matrix(QQ,2,2,[[1,2],[-1,2]])
f = P.Lattes_map(EllipticCurve([1, 1, 1, 1, 2]), 2)
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = P.Lattes_map(EllipticCurve([1, 1, 1, 2, 2]), 2)
sage: L.<i> = CyclotomicField(4)
sage: M = Matrix([[1+i,2*i], [0, -i]])
sage: f = f.conjugate(M)
sage: f.Lattes_to_curve(return_conjugation = True)
(
[              1 19/24*a + 19/24]
[              0               1],
Elliptic Curve defined by y^2 = x^3 + 95/96*a*x + (-1169/3456*a+1169/3456)
over Number Field in a with defining polynomial y^2 + 1
)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = P.Lattes_map(EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(2)]), Integer(2))
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[Integer(1)+i,Integer(2)*i], [Integer(0), -i]])
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[              1 19/24*a + 19/24]
[              0               1],
Elliptic Curve defined by y^2 = x^3 + 95/96*a*x + (-1169/3456*a+1169/3456)
over Number Field in a with defining polynomial y^2 + 1
)

P.<x,y> = ProjectiveSpace(QQ,1)
f = P.Lattes_map(EllipticCurve([1, 1, 1, 2, 2]), 2)
L.<i> = CyclotomicField(4)
M = Matrix([[1+i,2*i], [0, -i]])
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = P.Lattes_map(EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(2)]), Integer(2))
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[Integer(1)+i,Integer(2)*i], [Integer(0), -i]])
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[              1 19/24*a + 19/24]
[              0               1],
Elliptic Curve defined by y^2 = x^3 + 95/96*a*x + (-1169/3456*a+1169/3456)
over Number Field in a with defining polynomial y^2 + 1
)

P.<x,y> = ProjectiveSpace(QQ,1)
f = P.Lattes_map(EllipticCurve([1, 1, 1, 2, 2]), 2)
L.<i> = CyclotomicField(4)
M = Matrix([[1+i,2*i], [0, -i]])
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: M = matrix(QQ,2,2,[[1,3],[2,1]])
sage: E = EllipticCurve([1, 1, 1, 2, 3])
sage: f = P.Lattes_map(E, 2)
sage: f = f.conjugate(M)
sage: f.Lattes_to_curve(return_conjugation = True)
(
[11/1602*a^2 41/3204*a^2]
[     -2/5*a      -1/5*a],
Elliptic Curve defined by y^2 = x^3 + 2375/3421872*a^2*x + (-254125/61593696)
over Number Field in a with defining polynomial y^3 - 267
)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1),Integer(3)],[Integer(2),Integer(1)]])
>>> E = EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(3)])
>>> f = P.Lattes_map(E, Integer(2))
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[11/1602*a^2 41/3204*a^2]
[     -2/5*a      -1/5*a],
Elliptic Curve defined by y^2 = x^3 + 2375/3421872*a^2*x + (-254125/61593696)
over Number Field in a with defining polynomial y^3 - 267
)

P.<x,y> = ProjectiveSpace(QQ, 1)
M = matrix(QQ,2,2,[[1,3],[2,1]])
E = EllipticCurve([1, 1, 1, 2, 3])
f = P.Lattes_map(E, 2)
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1),Integer(3)],[Integer(2),Integer(1)]])
>>> E = EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(3)])
>>> f = P.Lattes_map(E, Integer(2))
>>> f = f.conjugate(M)
>>> f.Lattes_to_curve(return_conjugation = True)
(
[11/1602*a^2 41/3204*a^2]
[     -2/5*a      -1/5*a],
Elliptic Curve defined by y^2 = x^3 + 2375/3421872*a^2*x + (-254125/61593696)
over Number Field in a with defining polynomial y^3 - 267
)

P.<x,y> = ProjectiveSpace(QQ, 1)
M = matrix(QQ,2,2,[[1,3],[2,1]])
E = EllipticCurve([1, 1, 1, 2, 3])
f = P.Lattes_map(E, 2)
f = f.conjugate(M)
f.Lattes_to_curve(return_conjugation = True)
sage: P.<x,y> = ProjectiveSpace(QQ , 1)
sage: M = matrix(QQ,2,2,[[1 , 3],[2 , 1]])
sage: E = EllipticCurve([1, 1, 1, 2, 3])
sage: f = P.Lattes_map(E , 2)
sage: f = f.conjugate(M)
sage: m,H = f.Lattes_to_curve(true)
sage: J.<x,y> = ProjectiveSpace(H.base_ring(), 1)
sage: K = J.Lattes_map(H,2)
sage: K = K.conjugate(m)
sage: K.scale_by(f[0].lc()/K[0].lc())
sage: K == f.change_ring(K.base_ring())
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ , Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1) , Integer(3)],[Integer(2) , Integer(1)]])
>>> E = EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(3)])
>>> f = P.Lattes_map(E , Integer(2))
>>> f = f.conjugate(M)
>>> m,H = f.Lattes_to_curve(true)
>>> J = ProjectiveSpace(H.base_ring(), Integer(1), names=('x', 'y',)); (x, y,) = J._first_ngens(2)
>>> K = J.Lattes_map(H,Integer(2))
>>> K = K.conjugate(m)
>>> K.scale_by(f[Integer(0)].lc()/K[Integer(0)].lc())
>>> K == f.change_ring(K.base_ring())
True

P.<x,y> = ProjectiveSpace(QQ , 1)
M = matrix(QQ,2,2,[[1 , 3],[2 , 1]])
E = EllipticCurve([1, 1, 1, 2, 3])
f = P.Lattes_map(E , 2)
f = f.conjugate(M)
m,H = f.Lattes_to_curve(true)
J.<x,y> = ProjectiveSpace(H.base_ring(), 1)
K = J.Lattes_map(H,2)
K = K.conjugate(m)
K.scale_by(f[0].lc()/K[0].lc())
K == f.change_ring(K.base_ring())
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ , Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> M = matrix(QQ,Integer(2),Integer(2),[[Integer(1) , Integer(3)],[Integer(2) , Integer(1)]])
>>> E = EllipticCurve([Integer(1), Integer(1), Integer(1), Integer(2), Integer(3)])
>>> f = P.Lattes_map(E , Integer(2))
>>> f = f.conjugate(M)
>>> m,H = f.Lattes_to_curve(true)
>>> J = ProjectiveSpace(H.base_ring(), Integer(1), names=('x', 'y',)); (x, y,) = J._first_ngens(2)
>>> K = J.Lattes_map(H,Integer(2))
>>> K = K.conjugate(m)
>>> K.scale_by(f[Integer(0)].lc()/K[Integer(0)].lc())
>>> K == f.change_ring(K.base_ring())
True

P.<x,y> = ProjectiveSpace(QQ , 1)
M = matrix(QQ,2,2,[[1 , 3],[2 , 1]])
E = EllipticCurve([1, 1, 1, 2, 3])
f = P.Lattes_map(E , 2)
f = f.conjugate(M)
m,H = f.Lattes_to_curve(true)
J.<x,y> = ProjectiveSpace(H.base_ring(), 1)
K = J.Lattes_map(H,2)
K = K.conjugate(m)
K.scale_by(f[0].lc()/K[0].lc())
K == f.change_ring(K.base_ring())
sage: P.<x,y> = ProjectiveSpace(RR, 1)
sage: F = DynamicalSystem_projective([x^4, y^4])
sage: F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Base ring must be a number field

>>> from sage.all import *
>>> P = ProjectiveSpace(RR, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Base ring must be a number field

P.<x,y> = ProjectiveSpace(RR, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve(check_lattes=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(RR, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Base ring must be a number field

P.<x,y> = ProjectiveSpace(RR, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve(check_lattes=True)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^4, y^4])
sage: F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
ValueError: Map is not Lattes

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
ValueError: Map is not Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve(check_lattes=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
ValueError: Map is not Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve(check_lattes=True)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^4, y^4])
sage: F.Lattes_to_curve()
Traceback (most recent call last):
...
ValueError: No Solutions found. Check if map is Lattes

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve()
Traceback (most recent call last):
...
ValueError: No Solutions found. Check if map is Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.Lattes_to_curve()
Traceback (most recent call last):
...
ValueError: No Solutions found. Check if map is Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.Lattes_to_curve()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^3, y^3])
sage: F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Map is not Lattes or is Complex Lattes

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Map is not Lattes or is Complex Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, y^3])
F.Lattes_to_curve(check_lattes=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> F.Lattes_to_curve(check_lattes=True)
Traceback (most recent call last):
...
NotImplementedError: Map is not Lattes or is Complex Lattes

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, y^3])
F.Lattes_to_curve(check_lattes=True)
sage: K.<x>=QuadraticField(2)
sage: P.<a,y>=ProjectiveSpace(K, 1)
sage: E=EllipticCurve([1, x])
sage: f=P.Lattes_map(E, 2)
sage: f.Lattes_to_curve()
Elliptic Curve defined by y^2 = x^3 + x + a
over Number Field in a with defining polynomial y^2 - 2

>>> from sage.all import *
>>> K = QuadraticField(Integer(2), names=('x',)); (x,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('a', 'y',)); (a, y,) = P._first_ngens(2)
>>> E=EllipticCurve([Integer(1), x])
>>> f=P.Lattes_map(E, Integer(2))
>>> f.Lattes_to_curve()
Elliptic Curve defined by y^2 = x^3 + x + a
over Number Field in a with defining polynomial y^2 - 2

K.<x>=QuadraticField(2)
P.<a,y>=ProjectiveSpace(K, 1)
E=EllipticCurve([1, x])
f=P.Lattes_map(E, 2)
f.Lattes_to_curve()
>>> from sage.all import *
>>> K = QuadraticField(Integer(2), names=('x',)); (x,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('a', 'y',)); (a, y,) = P._first_ngens(2)
>>> E=EllipticCurve([Integer(1), x])
>>> f=P.Lattes_map(E, Integer(2))
>>> f.Lattes_to_curve()
Elliptic Curve defined by y^2 = x^3 + x + a
over Number Field in a with defining polynomial y^2 - 2

K.<x>=QuadraticField(2)
P.<a,y>=ProjectiveSpace(K, 1)
E=EllipticCurve([1, x])
f=P.Lattes_map(E, 2)
f.Lattes_to_curve()
sage: P.<x,y>=ProjectiveSpace(QQbar, 1)
sage: E=EllipticCurve([1, 2])
sage: f=P.Lattes_map(E, 2)
sage: f.Lattes_to_curve(check_lattes=true)
Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field

>>> from sage.all import *
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> E=EllipticCurve([Integer(1), Integer(2)])
>>> f=P.Lattes_map(E, Integer(2))
>>> f.Lattes_to_curve(check_lattes=true)
Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field

P.<x,y>=ProjectiveSpace(QQbar, 1)
E=EllipticCurve([1, 2])
f=P.Lattes_map(E, 2)
f.Lattes_to_curve(check_lattes=true)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> E=EllipticCurve([Integer(1), Integer(2)])
>>> f=P.Lattes_map(E, Integer(2))
>>> f.Lattes_to_curve(check_lattes=true)
Elliptic Curve defined by y^2 = x^3 + x + 2 over Rational Field

P.<x,y>=ProjectiveSpace(QQbar, 1)
E=EllipticCurve([1, 2])
f=P.Lattes_map(E, 2)
f.Lattes_to_curve(check_lattes=true)
affine_preperiodic_model(m, n, return_conjugation=False)[source]

Return a dynamical system conjugate to this one with affine (n, m) preperiodic points.

If the base ring of this dynamical system is finite, there may not be a model with affine preperiodic points, in which case a ValueError is raised.

INPUT:

  • m – the preperiod of the preperiodic points to make affine

  • n – the period of the preperiodic points to make affine

  • return_conjugation – boolean (default: False); if True, return a tuple (g, phi) where g is a model with affine (n, m) preperiodic points and phi is the matrix that moves f to g.

OUTPUT: a dynamical system conjugate to this one

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2])
sage: g = f.affine_preperiodic_model(0, 1); g                               # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2 over Rational Field
  Defn: Defined on coordinates by sending (x : y : z) to
        (-x^2 : -2*x^2 + 2*x*y - y^2 : 2*x^2 - 2*x*y + 2*y^2 + 2*y*z + z^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> g = f.affine_preperiodic_model(Integer(0), Integer(1)); g                               # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2 over Rational Field
  Defn: Defined on coordinates by sending (x : y : z) to
        (-x^2 : -2*x^2 + 2*x*y - y^2 : 2*x^2 - 2*x*y + 2*y^2 + 2*y*z + z^2)

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
g = f.affine_preperiodic_model(0, 1); g                               # needs sage.rings.function_field

We can check that g has affine fixed points:

sage: g.periodic_points(1)                                                  # needs sage.rings.function_field
[(-1 : -1 : 1),
 (-1/2 : -1 : 1),
 (-1/2 : -1/2 : 1),
 (-1/3 : -2/3 : 1),
 (0 : -1 : 1),
 (0 : -1/2 : 1),
 (0 : 0 : 1)]

>>> from sage.all import *
>>> g.periodic_points(Integer(1))                                                  # needs sage.rings.function_field
[(-1 : -1 : 1),
 (-1/2 : -1 : 1),
 (-1/2 : -1/2 : 1),
 (-1/3 : -2/3 : 1),
 (0 : -1 : 1),
 (0 : -1/2 : 1),
 (0 : 0 : 1)]

g.periodic_points(1)                                                  # needs sage.rings.function_field
sage: # needs sage.rings.finite_rings
sage: P.<x,y,z> = ProjectiveSpace(GF(9), 2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2])
sage: f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Finite Field in z2 of size 3^2
  Defn: Defined on coordinates by sending (x : y : z) to
        ((-z2)*x^2 : z2*x^2 + (-z2)*x*y + (-z2)*y^2 :
         (-z2)*x^2 + z2*x*y + (z2 + 1)*y^2 - y*z + z^2)

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(9)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.affine_preperiodic_model(Integer(0), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Finite Field in z2 of size 3^2
  Defn: Defined on coordinates by sending (x : y : z) to
        ((-z2)*x^2 : z2*x^2 + (-z2)*x*y + (-z2)*y^2 :
         (-z2)*x^2 + z2*x*y + (z2 + 1)*y^2 - y*z + z^2)

# needs sage.rings.finite_rings
P.<x,y,z> = ProjectiveSpace(GF(9), 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(9)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.affine_preperiodic_model(Integer(0), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Finite Field in z2 of size 3^2
  Defn: Defined on coordinates by sending (x : y : z) to
        ((-z2)*x^2 : z2*x^2 + (-z2)*x*y + (-z2)*y^2 :
         (-z2)*x^2 + z2*x*y + (z2 + 1)*y^2 - y*z + z^2)

# needs sage.rings.finite_rings
P.<x,y,z> = ProjectiveSpace(GF(9), 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
sage: R.<c> = GF(3)[]
sage: P.<x,y,z> = ProjectiveSpace(R, 2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2])
sage: f.affine_preperiodic_model(0, 1)  # long time
Dynamical System of Projective Space of dimension 2 over
 Univariate Polynomial Ring in c over Finite Field of size 3
  Defn: Defined on coordinates by sending (x : y : z) to
        (2*c^3*x^2 : c^3*x^2 + 2*c^3*x*y + 2*c^3*y^2 :
         2*c^3*x^2 + c^3*x*y + (c^3 + c^2)*y^2 + 2*c^2*y*z + c^2*z^2)

>>> from sage.all import *
>>> R = GF(Integer(3))['c']; (c,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.affine_preperiodic_model(Integer(0), Integer(1))  # long time
Dynamical System of Projective Space of dimension 2 over
 Univariate Polynomial Ring in c over Finite Field of size 3
  Defn: Defined on coordinates by sending (x : y : z) to
        (2*c^3*x^2 : c^3*x^2 + 2*c^3*x*y + 2*c^3*y^2 :
         2*c^3*x^2 + c^3*x*y + (c^3 + c^2)*y^2 + 2*c^2*y*z + c^2*z^2)

R.<c> = GF(3)[]
P.<x,y,z> = ProjectiveSpace(R, 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
f.affine_preperiodic_model(0, 1)  # long time
>>> from sage.all import *
>>> R = GF(Integer(3))['c']; (c,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.affine_preperiodic_model(Integer(0), Integer(1))  # long time
Dynamical System of Projective Space of dimension 2 over
 Univariate Polynomial Ring in c over Finite Field of size 3
  Defn: Defined on coordinates by sending (x : y : z) to
        (2*c^3*x^2 : c^3*x^2 + 2*c^3*x*y + 2*c^3*y^2 :
         2*c^3*x^2 + c^3*x*y + (c^3 + c^2)*y^2 + 2*c^2*y*z + c^2*z^2)

R.<c> = GF(3)[]
P.<x,y,z> = ProjectiveSpace(R, 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
f.affine_preperiodic_model(0, 1)  # long time
sage: # needs sage.rings.number_field
sage: K.<k> = CyclotomicField(3)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: f = DynamicalSystem_projective([x^2 + k*x*y + y^2, z^2, y^2])
sage: f.affine_preperiodic_model(1, 1)                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Cyclotomic Field of order 3 and degree 2
  Defn: Defined on coordinates by sending (x : y : z) to
        (-y^2 : x^2 : x^2 + (-k)*x*z + z^2)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('k',)); (k,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + k*x*y + y**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.affine_preperiodic_model(Integer(1), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Cyclotomic Field of order 3 and degree 2
  Defn: Defined on coordinates by sending (x : y : z) to
        (-y^2 : x^2 : x^2 + (-k)*x*z + z^2)

# needs sage.rings.number_field
K.<k> = CyclotomicField(3)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + k*x*y + y^2, z^2, y^2])
f.affine_preperiodic_model(1, 1)                                      # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('k',)); (k,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + k*x*y + y**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.affine_preperiodic_model(Integer(1), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 2
 over Cyclotomic Field of order 3 and degree 2
  Defn: Defined on coordinates by sending (x : y : z) to
        (-y^2 : x^2 : x^2 + (-k)*x*z + z^2)

# needs sage.rings.number_field
K.<k> = CyclotomicField(3)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + k*x*y + y^2, z^2, y^2])
f.affine_preperiodic_model(1, 1)                                      # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: g, mat = f.affine_preperiodic_model(0, 1, return_conjugation=True)    # needs sage.rings.function_field
sage: g == f.conjugate(mat)                                                 # needs sage.rings.function_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> g, mat = f.affine_preperiodic_model(Integer(0), Integer(1), return_conjugation=True)    # needs sage.rings.function_field
>>> g == f.conjugate(mat)                                                 # needs sage.rings.function_field
True

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
g, mat = f.affine_preperiodic_model(0, 1, return_conjugation=True)    # needs sage.rings.function_field
g == f.conjugate(mat)                                                 # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> g, mat = f.affine_preperiodic_model(Integer(0), Integer(1), return_conjugation=True)    # needs sage.rings.function_field
>>> g == f.conjugate(mat)                                                 # needs sage.rings.function_field
True

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
g, mat = f.affine_preperiodic_model(0, 1, return_conjugation=True)    # needs sage.rings.function_field
g == f.conjugate(mat)                                                 # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: X = P.subscheme(2*y - z)
sage: f = DynamicalSystem_projective([x^2 + y^2, z^2 + y^2, z^2], domain=X)
sage: f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension 2
 over Rational Field defined by: 2*y - z
  Defn: Defined on coordinates by sending (x : y : z) to
        (-x^2 - y^2 : y^2 : x^2 + z^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*y - z)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), z**Integer(2) + y**Integer(2), z**Integer(2)], domain=X)
>>> f.affine_preperiodic_model(Integer(0), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension 2
 over Rational Field defined by: 2*y - z
  Defn: Defined on coordinates by sending (x : y : z) to
        (-x^2 - y^2 : y^2 : x^2 + z^2)

P.<x,y,z> = ProjectiveSpace(QQ, 2)
X = P.subscheme(2*y - z)
f = DynamicalSystem_projective([x^2 + y^2, z^2 + y^2, z^2], domain=X)
f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*y - z)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), z**Integer(2) + y**Integer(2), z**Integer(2)], domain=X)
>>> f.affine_preperiodic_model(Integer(0), Integer(1))                                      # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension 2
 over Rational Field defined by: 2*y - z
  Defn: Defined on coordinates by sending (x : y : z) to
        (-x^2 - y^2 : y^2 : x^2 + z^2)

P.<x,y,z> = ProjectiveSpace(QQ, 2)
X = P.subscheme(2*y - z)
f = DynamicalSystem_projective([x^2 + y^2, z^2 + y^2, z^2], domain=X)
f.affine_preperiodic_model(0, 1)                                      # needs sage.rings.function_field
all_minimal_models(return_transformation=False, prime_list=None, algorithm=None, check_minimal=True)[source]

Determine a representative in each \(SL(2,\ZZ)\)-orbit of this map.

This can be done either with the Bruin-Molnar algorithm or the Hutz-Stoll algorithm. The Hutz-Stoll algorithm requires the map to have minimal resultant and then finds representatives in orbits with minimal resultant. The Bruin-Molnar algorithm finds representatives with the same resultant (up to sign) of the given map.

Bruin-Molnar does not work for polynomials and is more efficient for large primes.

INPUT:

  • return_transformation – boolean (default: False); this signals a return of the \(PGL_2\) transformation to conjugate this map to the calculated models

  • prime_list – (optional) a list of primes, in case one only wants to determine minimality at those specific primes

  • algorithm – (optional) string; can be one of the following:

    • 'BM' – the Bruin-Molnar algorithm [BM2012]

    • 'HS' – for the Hutz-Stoll algorithm [HS2018]

    if not specified, properties of the map are utilized to choose

  • check_minimal – (optional) boolean; to first check if the map is minimal and if not, compute a minimal model before computing for orbit representatives

OUTPUT:

A list of pairs \((F,m)\), where \(F\) is dynamical system on the projective line and \(m\) is the associated \(PGL(2,\QQ)\) element. Or just a list of dynamical systems if not returning the conjugation.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([2*x^2, 3*y^2])
sage: f.all_minimal_models()                                                # needs sage.rings.function_field
[Dynamical System of Projective Space of dimension 1 over Rational Field
   Defn: Defined on coordinates by sending (x : y) to
         (x^2 : y^2)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(2)*x**Integer(2), Integer(3)*y**Integer(2)])
>>> f.all_minimal_models()                                                # needs sage.rings.function_field
[Dynamical System of Projective Space of dimension 1 over Rational Field
   Defn: Defined on coordinates by sending (x : y) to
         (x^2 : y^2)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([2*x^2, 3*y^2])
f.all_minimal_models()                                                # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: c = 2*3^6
sage: f = DynamicalSystem([x^3 - c^2*y^3, x*y^2])
sage: len(f.all_minimal_models(algorithm='HS'))                             # needs sage.rings.function_field
14
sage: len(f.all_minimal_models(prime_list=[2], algorithm='HS'))             # needs sage.rings.function_field
2

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> c = Integer(2)*Integer(3)**Integer(6)
>>> f = DynamicalSystem([x**Integer(3) - c**Integer(2)*y**Integer(3), x*y**Integer(2)])
>>> len(f.all_minimal_models(algorithm='HS'))                             # needs sage.rings.function_field
14
>>> len(f.all_minimal_models(prime_list=[Integer(2)], algorithm='HS'))             # needs sage.rings.function_field
2

P.<x,y> = ProjectiveSpace(QQ, 1)
c = 2*3^6
f = DynamicalSystem([x^3 - c^2*y^3, x*y^2])
len(f.all_minimal_models(algorithm='HS'))                             # needs sage.rings.function_field
len(f.all_minimal_models(prime_list=[2], algorithm='HS'))             # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> c = Integer(2)*Integer(3)**Integer(6)
>>> f = DynamicalSystem([x**Integer(3) - c**Integer(2)*y**Integer(3), x*y**Integer(2)])
>>> len(f.all_minimal_models(algorithm='HS'))                             # needs sage.rings.function_field
14
>>> len(f.all_minimal_models(prime_list=[Integer(2)], algorithm='HS'))             # needs sage.rings.function_field
2

P.<x,y> = ProjectiveSpace(QQ, 1)
c = 2*3^6
f = DynamicalSystem([x^3 - c^2*y^3, x*y^2])
len(f.all_minimal_models(algorithm='HS'))                             # needs sage.rings.function_field
len(f.all_minimal_models(prime_list=[2], algorithm='HS'))             # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([237568*x^3 + 1204224*x^2*y + 2032560*x*y^2
....:     + 1142289*y^3, -131072*x^3 - 663552*x^2*y - 1118464*x*y^2
....:     - 627664*y^3])
sage: len(f.all_minimal_models(algorithm='BM'))                             # needs sage.rings.function_field
2

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(237568)*x**Integer(3) + Integer(1204224)*x**Integer(2)*y + Integer(2032560)*x*y**Integer(2)
...     + Integer(1142289)*y**Integer(3), -Integer(131072)*x**Integer(3) - Integer(663552)*x**Integer(2)*y - Integer(1118464)*x*y**Integer(2)
...     - Integer(627664)*y**Integer(3)])
>>> len(f.all_minimal_models(algorithm='BM'))                             # needs sage.rings.function_field
2

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([237568*x^3 + 1204224*x^2*y + 2032560*x*y^2
    + 1142289*y^3, -131072*x^3 - 663552*x^2*y - 1118464*x*y^2
    - 627664*y^3])
len(f.all_minimal_models(algorithm='BM'))                             # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(237568)*x**Integer(3) + Integer(1204224)*x**Integer(2)*y + Integer(2032560)*x*y**Integer(2)
...     + Integer(1142289)*y**Integer(3), -Integer(131072)*x**Integer(3) - Integer(663552)*x**Integer(2)*y - Integer(1118464)*x*y**Integer(2)
...     - Integer(627664)*y**Integer(3)])
>>> len(f.all_minimal_models(algorithm='BM'))                             # needs sage.rings.function_field
2

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([237568*x^3 + 1204224*x^2*y + 2032560*x*y^2
    + 1142289*y^3, -131072*x^3 - 663552*x^2*y - 1118464*x*y^2
    - 627664*y^3])
len(f.all_minimal_models(algorithm='BM'))                             # needs sage.rings.function_field

REFERENCES:

arakelov_zhang_pairing(g, **kwds)[source]

Return an estimate of the Arakelov-Zhang pairing of the rational maps self and g on \(\mathbb{P}^1\) over a number field.

The Arakelov-Zhang pairing was introduced by Petsche, Szpiro, and Tucker in 2012, which measures the dynamical closeness of two rational maps. They prove inter alia that if one takes a sequence of small points for one map (for example, preperiodic points for self) and measure their dynamical height with respect to the other map (say, g), then the values of the height will tend to the value of the Arakelov-Zhang pairing.

The Arakelov-Zhang pairing involves mutual energy integrals between dynamical measures, which are in the case of polynomials, the equilibrium measures of the associated Julia sets at each place. As a result, these pairings are very difficult to compute exactly via analytic methods. We use a discrete approximation to these energy integrals.

ALGORITHM:

We select periodic points of order \(n\), or n-th preimages of a specified starting value given by f_starting_point and g_starting_point. At the archimedean places and the places of bad reduction of the two maps, we compute the discrete approximations to the energy integrals involved using these points.

INPUT:

  • g – a rational map of \(\mathbb{P}^1\) given as a projective morphism g and self should have the same field of definition

kwds:

  • n – positive integer (default: 5); order of periodic points to use or preimages to take if starting points are specified

  • f_starting_point – (default: None) value in the base number field or None. If f_starting_point is None, we solve for points of period n for self. Otherwise, we take n-th preimages of the point given by f_starting_point under f on the affine line.

  • g_starting_point – (default: None) value in the base number field or None. If g_starting_point is None, we solve for points of period n for g. Otherwise, we take n-th preimages of the point given by g_starting_point under g on the affine line.

  • check_primes_of_bad_reduction – boolean (default: False); passed to the primes_of_bad_reduction function for self and g

  • prec – (default: RealField default); default precision for RealField values which are returned

  • noise_multiplier – (default: 2) a real number. Discriminant terms involved in the computation at the archimedean places are often not needed, particularly if the capacity of the Julia sets is 1, and introduce a lot of error. By a well-known result of Mahler (see also M. Baker, “”A lower bound for averages of dynamical Green’s functions”) such error (for a set of \(N\) points) is on the order of \(\log(N)/N\) after our normalization. We check if the value of the archimedean discriminant terms is within 2*noise_multiplier of \(\log(N)/N\). If so, we discard it. In practice this greatly improves the accuracy of the estimate of the pairing. If desired, noise_multiplier can be set to 0, and no terms will be ignored.

OUTPUT: a real number estimating the Arakelov-Zhang pairing of the two rational maps

EXAMPLES:

sage: # needs sage.rings.number_field
sage: K.<k> = CyclotomicField(3)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 + (2*k + 2)*y^2, y^2])
sage: g = DynamicalSystem_projective([x^2, y^2])
sage: pairingval = f.arakelov_zhang_pairing(g, n=5); pairingval
0.409598197761958

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('k',)); (k,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + (Integer(2)*k + Integer(2))*y**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> pairingval = f.arakelov_zhang_pairing(g, n=Integer(5)); pairingval
0.409598197761958

# needs sage.rings.number_field
K.<k> = CyclotomicField(3)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 + (2*k + 2)*y^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])
pairingval = f.arakelov_zhang_pairing(g, n=5); pairingval
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 4*y^2, y^2])
sage: g = DynamicalSystem_projective([x^2, y^2])
sage: pairingval = f.arakelov_zhang_pairing(g, n=6); pairingval             # needs sage.rings.function_field
0.750178391443644
sage: # Compare to the exact value:
sage: dynheight = f.canonical_height(P(0, 1)); dynheight                    # needs sage.libs.pari
0.75017839144364417318023000563
sage: dynheight - pairingval                                                # needs sage.libs.pari sage.rings.function_field
0.000000000000000

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(4)*y**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> pairingval = f.arakelov_zhang_pairing(g, n=Integer(6)); pairingval             # needs sage.rings.function_field
0.750178391443644
>>> # Compare to the exact value:
>>> dynheight = f.canonical_height(P(Integer(0), Integer(1))); dynheight                    # needs sage.libs.pari
0.75017839144364417318023000563
>>> dynheight - pairingval                                                # needs sage.libs.pari sage.rings.function_field
0.000000000000000

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 4*y^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])
pairingval = f.arakelov_zhang_pairing(g, n=6); pairingval             # needs sage.rings.function_field
# Compare to the exact value:
dynheight = f.canonical_height(P(0, 1)); dynheight                    # needs sage.libs.pari
dynheight - pairingval                                                # needs sage.libs.pari sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(4)*y**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> pairingval = f.arakelov_zhang_pairing(g, n=Integer(6)); pairingval             # needs sage.rings.function_field
0.750178391443644
>>> # Compare to the exact value:
>>> dynheight = f.canonical_height(P(Integer(0), Integer(1))); dynheight                    # needs sage.libs.pari
0.75017839144364417318023000563
>>> dynheight - pairingval                                                # needs sage.libs.pari sage.rings.function_field
0.000000000000000

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 4*y^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])
pairingval = f.arakelov_zhang_pairing(g, n=6); pairingval             # needs sage.rings.function_field
# Compare to the exact value:
dynheight = f.canonical_height(P(0, 1)); dynheight                    # needs sage.libs.pari
dynheight - pairingval                                                # needs sage.libs.pari sage.rings.function_field

Notice that if we set the noise_multiplier to 0, the accuracy is diminished:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 4*y^2, y^2])
sage: g = DynamicalSystem_projective([x^2, y^2])
sage: pairingval = f.arakelov_zhang_pairing(g, n=6, noise_multiplier=0)     # needs sage.rings.function_field
sage: pairingval                                                            # needs sage.rings.number_field
0.650660018921632
sage: dynheight = f.canonical_height(P(0, 1)); dynheight                    # needs sage.libs.pari
0.75017839144364417318023000563
sage: pairingval - dynheight                                                # needs sage.libs.pari sage.rings.function_field
-0.0995183725220122

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(4)*y**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> pairingval = f.arakelov_zhang_pairing(g, n=Integer(6), noise_multiplier=Integer(0))     # needs sage.rings.function_field
>>> pairingval                                                            # needs sage.rings.number_field
0.650660018921632
>>> dynheight = f.canonical_height(P(Integer(0), Integer(1))); dynheight                    # needs sage.libs.pari
0.75017839144364417318023000563
>>> pairingval - dynheight                                                # needs sage.libs.pari sage.rings.function_field
-0.0995183725220122

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 4*y^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])
pairingval = f.arakelov_zhang_pairing(g, n=6, noise_multiplier=0)     # needs sage.rings.function_field
pairingval                                                            # needs sage.rings.number_field
dynheight = f.canonical_height(P(0, 1)); dynheight                    # needs sage.libs.pari
pairingval - dynheight                                                # needs sage.libs.pari sage.rings.function_field

We compute the example of Prop. 18(d) from Petsche, Szpiro and Tucker:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([y^2 - (y - x)^2, y^2])
sage: g = DynamicalSystem_projective([x^2, y^2])
sage: f.arakelov_zhang_pairing(g)                                           # needs sage.rings.function_field
0.326954667248466
sage: # Correct value should be = 0.323067...
sage: f.arakelov_zhang_pairing(g, n=9)      # long time                     # needs sage.rings.function_field
0.323091061918965
sage: _ - 0.323067                          # long time                     # needs sage.rings.function_field
0.0000240619189654789

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([y**Integer(2) - (y - x)**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])
>>> f.arakelov_zhang_pairing(g)                                           # needs sage.rings.function_field
0.326954667248466
>>> # Correct value should be = 0.323067...
>>> f.arakelov_zhang_pairing(g, n=Integer(9))      # long time                     # needs sage.rings.function_field
0.323091061918965
>>> _ - RealNumber('0.323067')                          # long time                     # needs sage.rings.function_field
0.0000240619189654789

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([y^2 - (y - x)^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])
f.arakelov_zhang_pairing(g)                                           # needs sage.rings.function_field
# Correct value should be = 0.323067...
f.arakelov_zhang_pairing(g, n=9)      # long time                     # needs sage.rings.function_field
_ - 0.323067                          # long time                     # needs sage.rings.function_field

Also from Prop. 18 of Petsche, Szpiro and Tucker, includes places of bad reduction:

sage: # needs sage.rings.number_field
sage: R.<z> = PolynomialRing(ZZ)
sage: K.<b> = NumberField(z^3 - 11)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: a = 7/(b - 1)
sage: f = DynamicalSystem_projective([a*y^2 - (a*y - x)^2, y^2])
sage: g = DynamicalSystem_projective([x^2, y^2])

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(ZZ, names=('z',)); (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(3) - Integer(11), names=('b',)); (b,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> a = Integer(7)/(b - Integer(1))
>>> f = DynamicalSystem_projective([a*y**Integer(2) - (a*y - x)**Integer(2), y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2), y**Integer(2)])

# needs sage.rings.number_field
R.<z> = PolynomialRing(ZZ)
K.<b> = NumberField(z^3 - 11)
P.<x,y> = ProjectiveSpace(K,1)
a = 7/(b - 1)
f = DynamicalSystem_projective([a*y^2 - (a*y - x)^2, y^2])
g = DynamicalSystem_projective([x^2, y^2])

If all archimedean absolute values of a have modulus > 2, then the pairing should be h(a).:

sage: f.arakelov_zhang_pairing(g, n=6)      # long time                     # needs sage.rings.number_field
1.93846423207664
sage: _ - a.global_height()                 # long time                     # needs sage.rings.number_field
-0.00744591697867292

>>> from sage.all import *
>>> f.arakelov_zhang_pairing(g, n=Integer(6))      # long time                     # needs sage.rings.number_field
1.93846423207664
>>> _ - a.global_height()                 # long time                     # needs sage.rings.number_field
-0.00744591697867292

f.arakelov_zhang_pairing(g, n=6)      # long time                     # needs sage.rings.number_field
_ - a.global_height()                 # long time                     # needs sage.rings.number_field
automorphism_group(**kwds)[source]

Calculate the subgroup of \(PGL2\) that is the automorphism group of this dynamical system.

The automorphism group is the set of \(PGL(2)\) elements that fixes this map under conjugation.

INPUT:

The following keywords are used in most cases:

  • num_cpus – (default: 2) the number of threads to use. Setting to a larger number can greatly speed up this function

The following keywords are used only when the dimension of the domain is 1 and the base ring is the rationals, but ignored in all other cases:

  • starting_prime – (default: 5) the first prime to use for CRT

  • algorithm – (optional) can be one of the following:

    • 'CRT' – Chinese Remainder Theorem

    • 'fixed_points' – fixed points algorithm

  • return_functions – boolean (default: False); True returns elements as linear fractional transformations and False returns elements as \(PGL2\) matrices

  • iso_type – boolean (default: False); True returns the isomorphism type of the automorphism group

OUTPUT: list of elements in the automorphism group

AUTHORS:

  • Original algorithm written by Xander Faber, Michelle Manes, Bianca Viray

  • Modified by Joao Alberto de Faria, Ben Hutz, Bianca Thompson

REFERENCES:

EXAMPLES:

sage: R.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - y^2, x*y])
sage: f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
[x, -x]

>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y])
>>> f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
[x, -x]

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - y^2, x*y])
f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
sage: R.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 5*x*y + 5*y^2, 5*x^2 + 5*x*y + y^2])
sage: f.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]
[0 1], [2 0]
]

>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(5)*x*y + Integer(5)*y**Integer(2), Integer(5)*x**Integer(2) + Integer(5)*x*y + y**Integer(2)])
>>> f.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]
[0 1], [2 0]
]

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 5*x*y + 5*y^2, 5*x^2 + 5*x*y + y^2])
f.automorphism_group()                                                # needs sage.libs.pari
>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(5)*x*y + Integer(5)*y**Integer(2), Integer(5)*x**Integer(2) + Integer(5)*x*y + y**Integer(2)])
>>> f.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]
[0 1], [2 0]
]

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 5*x*y + 5*y^2, 5*x^2 + 5*x*y + y^2])
f.automorphism_group()                                                # needs sage.libs.pari
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem([x^3, y^3, z^3])
sage: len(f.automorphism_group())                                           # needs sage.rings.function_field
24

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(3), y**Integer(3), z**Integer(3)])
>>> len(f.automorphism_group())                                           # needs sage.rings.function_field
24

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem([x^3, y^3, z^3])
len(f.automorphism_group())                                           # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(3), y**Integer(3), z**Integer(3)])
>>> len(f.automorphism_group())                                           # needs sage.rings.function_field
24

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem([x^3, y^3, z^3])
len(f.automorphism_group())                                           # needs sage.rings.function_field
sage: R.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 2*x*y - 2*y^2, -2*x^2 - 2*x*y + y^2])
sage: f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
[x, 1/x, -x - 1, -x/(x + 1), (-x - 1)/x, -1/(x + 1)]

>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*x*y - Integer(2)*y**Integer(2), -Integer(2)*x**Integer(2) - Integer(2)*x*y + y**Integer(2)])
>>> f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
[x, 1/x, -x - 1, -x/(x + 1), (-x - 1)/x, -1/(x + 1)]

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 2*x*y - 2*y^2, -2*x^2 - 2*x*y + y^2])
f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*x*y - Integer(2)*y**Integer(2), -Integer(2)*x**Integer(2) - Integer(2)*x*y + y**Integer(2)])
>>> f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
[x, 1/x, -x - 1, -x/(x + 1), (-x - 1)/x, -1/(x + 1)]

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 2*x*y - 2*y^2, -2*x^2 - 2*x*y + y^2])
f.automorphism_group(return_functions=True)                           # needs sage.libs.pari
sage: R.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([3*x^2*y - y^3, x^3 - 3*x*y^2])
sage: lst, label = f.automorphism_group(algorithm='CRT',                    # needs sage.libs.pari
....:                                   return_functions=True,
....:                                   iso_type=True)
sage: sorted(lst), label                                                    # needs sage.libs.pari
([-1/x, 1/x, (-x - 1)/(x - 1), (-x + 1)/(x + 1), (x - 1)/(x + 1),
  (x + 1)/(x - 1), -x, x],
 'Dihedral of order 8')

>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2)*y - y**Integer(3), x**Integer(3) - Integer(3)*x*y**Integer(2)])
>>> lst, label = f.automorphism_group(algorithm='CRT',                    # needs sage.libs.pari
...                                   return_functions=True,
...                                   iso_type=True)
>>> sorted(lst), label                                                    # needs sage.libs.pari
([-1/x, 1/x, (-x - 1)/(x - 1), (-x + 1)/(x + 1), (x - 1)/(x + 1),
  (x + 1)/(x - 1), -x, x],
 'Dihedral of order 8')

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([3*x^2*y - y^3, x^3 - 3*x*y^2])
lst, label = f.automorphism_group(algorithm='CRT',                    # needs sage.libs.pari
                                  return_functions=True,
                                  iso_type=True)
sorted(lst), label                                                    # needs sage.libs.pari
>>> from sage.all import *
>>> R = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2)*y - y**Integer(3), x**Integer(3) - Integer(3)*x*y**Integer(2)])
>>> lst, label = f.automorphism_group(algorithm='CRT',                    # needs sage.libs.pari
...                                   return_functions=True,
...                                   iso_type=True)
>>> sorted(lst), label                                                    # needs sage.libs.pari
([-1/x, 1/x, (-x - 1)/(x - 1), (-x + 1)/(x + 1), (x - 1)/(x + 1),
  (x + 1)/(x - 1), -x, x],
 'Dihedral of order 8')

R.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([3*x^2*y - y^3, x^3 - 3*x*y^2])
lst, label = f.automorphism_group(algorithm='CRT',                    # needs sage.libs.pari
                                  return_functions=True,
                                  iso_type=True)
sorted(lst), label                                                    # needs sage.libs.pari
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem_affine([1/z^3])
sage: F = f.homogenize(1)
sage: F.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]  [-1  0]  [ 0 -2]
[0 1], [2 0], [ 0  1], [ 2  0]
]

>>> from sage.all import *
>>> A = AffineSpace(QQ, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([Integer(1)/z**Integer(3)])
>>> F = f.homogenize(Integer(1))
>>> F.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]  [-1  0]  [ 0 -2]
[0 1], [2 0], [ 0  1], [ 2  0]
]

A.<z> = AffineSpace(QQ, 1)
f = DynamicalSystem_affine([1/z^3])
F = f.homogenize(1)
F.automorphism_group()                                                # needs sage.libs.pari
>>> from sage.all import *
>>> A = AffineSpace(QQ, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([Integer(1)/z**Integer(3)])
>>> F = f.homogenize(Integer(1))
>>> F.automorphism_group()                                                # needs sage.libs.pari
[
[1 0]  [0 2]  [-1  0]  [ 0 -2]
[0 1], [2 0], [ 0  1], [ 2  0]
]

A.<z> = AffineSpace(QQ, 1)
f = DynamicalSystem_affine([1/z^3])
F = f.homogenize(1)
F.automorphism_group()                                                # needs sage.libs.pari
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x**2 + x*z, y**2, z**2])
sage: f.automorphism_group()                                                # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*z, y**Integer(2), z**Integer(2)])
>>> f.automorphism_group()                                                # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x**2 + x*z, y**2, z**2])
f.automorphism_group()                                                # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*z, y**Integer(2), z**Integer(2)])
>>> f.automorphism_group()                                                # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x**2 + x*z, y**2, z**2])
f.automorphism_group()                                                # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: K.<w> = CyclotomicField(3)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: D6 = DynamicalSystem_projective([y^2, x^2])
sage: sorted(D6.automorphism_group())
[
[-w - 1      0]  [     0 -w - 1]  [w 0]  [0 w]  [0 1]  [1 0]
[     0      1], [     1      0], [0 1], [1 0], [1 0], [0 1]
]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D6 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> sorted(D6.automorphism_group())
[
[-w - 1      0]  [     0 -w - 1]  [w 0]  [0 w]  [0 1]  [1 0]
[     0      1], [     1      0], [0 1], [1 0], [1 0], [0 1]
]

# needs sage.rings.number_field
K.<w> = CyclotomicField(3)
P.<x,y> = ProjectiveSpace(K, 1)
D6 = DynamicalSystem_projective([y^2, x^2])
sorted(D6.automorphism_group())
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D6 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> sorted(D6.automorphism_group())
[
[-w - 1      0]  [     0 -w - 1]  [w 0]  [0 w]  [0 1]  [1 0]
[     0      1], [     1      0], [0 1], [1 0], [1 0], [0 1]
]

# needs sage.rings.number_field
K.<w> = CyclotomicField(3)
P.<x,y> = ProjectiveSpace(K, 1)
D6 = DynamicalSystem_projective([y^2, x^2])
sorted(D6.automorphism_group())
canonical_height(P, **kwds)[source]

Evaluate the (absolute) canonical height of P with respect to this dynamical system.

Must be over number field or order of a number field. Specify either the number of terms of the series to evaluate or the error bound required.

ALGORITHM:

The sum of the Green’s function at the archimedean places and the places of bad reduction.

If function is defined over \(\QQ\) uses Wells’ Algorithm, which allows us to not have to factor the resultant.

INPUT:

  • P – a projective point

kwds:

  • badprimes – (optional) a list of primes of bad reduction

  • N – (default: 10) positive integer; number of terms of the series to use in the local green functions

  • prec – (default: 100) positive integer, float point or \(p\)-adic precision

  • error_bound – (optional) a positive real number

OUTPUT: a real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 2*x*y]);
sage: f.canonical_height(P.point([5,4]), error_bound=0.001)                 # needs sage.libs.pari
2.1970553519503404898926835324
sage: f.canonical_height(P.point([2,1]), error_bound=0.001)                 # needs sage.libs.pari
1.0984430632822307984974382955

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*x*y]);
>>> f.canonical_height(P.point([Integer(5),Integer(4)]), error_bound=RealNumber('0.001'))                 # needs sage.libs.pari
2.1970553519503404898926835324
>>> f.canonical_height(P.point([Integer(2),Integer(1)]), error_bound=RealNumber('0.001'))                 # needs sage.libs.pari
1.0984430632822307984974382955

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, 2*x*y]);
f.canonical_height(P.point([5,4]), error_bound=0.001)                 # needs sage.libs.pari
f.canonical_height(P.point([2,1]), error_bound=0.001)                 # needs sage.libs.pari

Notice that preperiodic points may not return exactly 0:

sage: # needs sage.rings.number_field
sage: R.<X> = PolynomialRing(QQ)
sage: K.<a> = NumberField(X^2 + X - 1)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: Q = P.point([a,1])
sage: f.canonical_height(Q, error_bound=0.000001)  # Answer only within error_bound of 0
5.7364919788790160119266380480e-8
sage: f.nth_iterate(Q, 2) == Q  # but it is indeed preperiodic
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('X',)); (X,) = R._first_ngens(1)
>>> K = NumberField(X**Integer(2) + X - Integer(1), names=('a',)); (a,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> Q = P.point([a,Integer(1)])
>>> f.canonical_height(Q, error_bound=RealNumber('0.000001'))  # Answer only within error_bound of 0
5.7364919788790160119266380480e-8
>>> f.nth_iterate(Q, Integer(2)) == Q  # but it is indeed preperiodic
True

# needs sage.rings.number_field
R.<X> = PolynomialRing(QQ)
K.<a> = NumberField(X^2 + X - 1)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
Q = P.point([a,1])
f.canonical_height(Q, error_bound=0.000001)  # Answer only within error_bound of 0
f.nth_iterate(Q, 2) == Q  # but it is indeed preperiodic
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: X = P.subscheme(x^2 - y^2);
sage: f = DynamicalSystem_projective([x^2, y^2, 4*z^2], domain=X);
sage: Q = X([4,4,1])
sage: f.canonical_height(Q, badprimes=[2])                                  # needs sage.rings.function_field
0.0013538030870311431824555314882

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2));
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), Integer(4)*z**Integer(2)], domain=X);
>>> Q = X([Integer(4),Integer(4),Integer(1)])
>>> f.canonical_height(Q, badprimes=[Integer(2)])                                  # needs sage.rings.function_field
0.0013538030870311431824555314882

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x^2 - y^2);
f = DynamicalSystem_projective([x^2, y^2, 4*z^2], domain=X);
Q = X([4,4,1])
f.canonical_height(Q, badprimes=[2])                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2));
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), Integer(4)*z**Integer(2)], domain=X);
>>> Q = X([Integer(4),Integer(4),Integer(1)])
>>> f.canonical_height(Q, badprimes=[Integer(2)])                                  # needs sage.rings.function_field
0.0013538030870311431824555314882

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x^2 - y^2);
f = DynamicalSystem_projective([x^2, y^2, 4*z^2], domain=X);
Q = X([4,4,1])
f.canonical_height(Q, badprimes=[2])                                  # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: X = P.subscheme(x^2 - y^2);
sage: f = DynamicalSystem_projective([x^2, y^2, 30*z^2], domain=X)
sage: Q = X([4, 4, 1])
sage: f.canonical_height(Q, badprimes=[2,3,5], prec=200)                    # needs sage.rings.function_field
2.7054056208276961889784303469356774912979228770208655455481

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2));
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), Integer(30)*z**Integer(2)], domain=X)
>>> Q = X([Integer(4), Integer(4), Integer(1)])
>>> f.canonical_height(Q, badprimes=[Integer(2),Integer(3),Integer(5)], prec=Integer(200))                    # needs sage.rings.function_field
2.7054056208276961889784303469356774912979228770208655455481

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x^2 - y^2);
f = DynamicalSystem_projective([x^2, y^2, 30*z^2], domain=X)
Q = X([4, 4, 1])
f.canonical_height(Q, badprimes=[2,3,5], prec=200)                    # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2));
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), Integer(30)*z**Integer(2)], domain=X)
>>> Q = X([Integer(4), Integer(4), Integer(1)])
>>> f.canonical_height(Q, badprimes=[Integer(2),Integer(3),Integer(5)], prec=Integer(200))                    # needs sage.rings.function_field
2.7054056208276961889784303469356774912979228770208655455481

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x^2 - y^2);
f = DynamicalSystem_projective([x^2, y^2, 30*z^2], domain=X)
Q = X([4, 4, 1])
f.canonical_height(Q, badprimes=[2,3,5], prec=200)                    # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([1000*x^2 - 29*y^2, 1000*y^2])
sage: Q = P(-1/4, 1)
sage: f.canonical_height(Q, error_bound=0.01)                               # needs sage.libs.pari
3.7996079979254623065837411853

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1000)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(1000)*y**Integer(2)])
>>> Q = P(-Integer(1)/Integer(4), Integer(1))
>>> f.canonical_height(Q, error_bound=RealNumber('0.01'))                               # needs sage.libs.pari
3.7996079979254623065837411853

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([1000*x^2 - 29*y^2, 1000*y^2])
Q = P(-1/4, 1)
f.canonical_height(Q, error_bound=0.01)                               # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1000)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(1000)*y**Integer(2)])
>>> Q = P(-Integer(1)/Integer(4), Integer(1))
>>> f.canonical_height(Q, error_bound=RealNumber('0.01'))                               # needs sage.libs.pari
3.7996079979254623065837411853

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([1000*x^2 - 29*y^2, 1000*y^2])
Q = P(-1/4, 1)
f.canonical_height(Q, error_bound=0.01)                               # needs sage.libs.pari
sage: RSA768 = 123018668453011775513049495838496272077285356959533479219732245215\
....: 1726400507263657518745202199786469389956474942774063845925192557326303453731548\
....: 2685079170261221429134616704292143116022212404792747377940806653514195974598569\
....: 02143413
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([RSA768*x^2 + y^2, x*y])
sage: Q = P(RSA768,1)
sage: f.canonical_height(Q, error_bound=0.00000000000000001)                # needs sage.libs.pari
931.18256422718241278672729195

>>> from sage.all import *
>>> RSA768 = Integer(123018668453011775513049495838496272077285356959533479219732245215)Integer(1726400507263657518745202199786469389956474942774063845925192557326303453731548)Integer(2685079170261221429134616704292143116022212404792747377940806653514195974598569)Integer(2143413)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([RSA768*x**Integer(2) + y**Integer(2), x*y])
>>> Q = P(RSA768,Integer(1))
>>> f.canonical_height(Q, error_bound=RealNumber('0.00000000000000001'))                # needs sage.libs.pari
931.18256422718241278672729195

RSA768 = 123018668453011775513049495838496272077285356959533479219732245215\
1726400507263657518745202199786469389956474942774063845925192557326303453731548\
2685079170261221429134616704292143116022212404792747377940806653514195974598569\
02143413
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([RSA768*x^2 + y^2, x*y])
Q = P(RSA768,1)
f.canonical_height(Q, error_bound=0.00000000000000001)                # needs sage.libs.pari
>>> from sage.all import *
>>> RSA768 = Integer(123018668453011775513049495838496272077285356959533479219732245215)Integer(1726400507263657518745202199786469389956474942774063845925192557326303453731548)Integer(2685079170261221429134616704292143116022212404792747377940806653514195974598569)Integer(2143413)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([RSA768*x**Integer(2) + y**Integer(2), x*y])
>>> Q = P(RSA768,Integer(1))
>>> f.canonical_height(Q, error_bound=RealNumber('0.00000000000000001'))                # needs sage.libs.pari
931.18256422718241278672729195

RSA768 = 123018668453011775513049495838496272077285356959533479219732245215\
1726400507263657518745202199786469389956474942774063845925192557326303453731548\
2685079170261221429134616704292143116022212404792747377940806653514195974598569\
02143413
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([RSA768*x^2 + y^2, x*y])
Q = P(RSA768,1)
f.canonical_height(Q, error_bound=0.00000000000000001)                # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([2*(-2*x^3 + 3*(x^2*y)) + 3*y^3, 3*y^3])
sage: f.canonical_height(P(1,0))                                            # needs sage.libs.pari
0.00000000000000000000000000000

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(2)*(-Integer(2)*x**Integer(3) + Integer(3)*(x**Integer(2)*y)) + Integer(3)*y**Integer(3), Integer(3)*y**Integer(3)])
>>> f.canonical_height(P(Integer(1),Integer(0)))                                            # needs sage.libs.pari
0.00000000000000000000000000000

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([2*(-2*x^3 + 3*(x^2*y)) + 3*y^3, 3*y^3])
f.canonical_height(P(1,0))                                            # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(2)*(-Integer(2)*x**Integer(3) + Integer(3)*(x**Integer(2)*y)) + Integer(3)*y**Integer(3), Integer(3)*y**Integer(3)])
>>> f.canonical_height(P(Integer(1),Integer(0)))                                            # needs sage.libs.pari
0.00000000000000000000000000000

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([2*(-2*x^3 + 3*(x^2*y)) + 3*y^3, 3*y^3])
f.canonical_height(P(1,0))                                            # needs sage.libs.pari
conjugate(M, adjugate=False, normalize=False)[source]

Conjugate this dynamical system by M, i.e. \(M^{-1} \circ f \circ M\).

If possible the new map will be defined over the same space. Otherwise, will try to coerce to the base ring of M.

INPUT:

  • M – a square invertible matrix

  • adjugate – boolean (default: False); also classically called adjoint, takes a square matrix M and finds the transpose of its cofactor matrix. Used for conjugation in place of inverse when specified True. Functionality is the same in projective space.

  • normalize – boolean (default: False); if normalize is True, then the method normalize_coordinates is called

OUTPUT: a dynamical system

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.conjugate(matrix([[1,2], [0,1]]))
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + 4*x*y + 3*y^2 : y^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.conjugate(matrix([[Integer(1),Integer(2)], [Integer(0),Integer(1)]]))
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + 4*x*y + 3*y^2 : y^2)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.conjugate(matrix([[1,2], [0,1]]))
sage: R.<x> = PolynomialRing(QQ)
sage: K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^3 + y^3, y^3])
sage: f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to
        (-x^3 + y^3 : -y^3)

>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + y**Integer(3), y**Integer(3)])
>>> f.conjugate(matrix([[i,Integer(0)], [Integer(0),-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to
        (-x^3 + y^3 : -y^3)

R.<x> = PolynomialRing(QQ)
K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^3 + y^3, y^3])
f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field
>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + y**Integer(3), y**Integer(3)])
>>> f.conjugate(matrix([[i,Integer(0)], [Integer(0),-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to
        (-x^3 + y^3 : -y^3)

R.<x> = PolynomialRing(QQ)
K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^3 + y^3, y^3])
f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2, y*z])
sage: f.conjugate(matrix([[1,2,3], [0,1,2], [0,0,1]]))
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + 4*x*y + 3*y^2 + 6*x*z + 9*y*z + 7*z^2 : y^2 + 2*y*z : y*z + 2*z^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), y*z])
>>> f.conjugate(matrix([[Integer(1),Integer(2),Integer(3)], [Integer(0),Integer(1),Integer(2)], [Integer(0),Integer(0),Integer(1)]]))
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + 4*x*y + 3*y^2 + 6*x*z + 9*y*z + 7*z^2 : y^2 + 2*y*z : y*z + 2*z^2)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, y*z])
f.conjugate(matrix([[1,2,3], [0,1,2], [0,0,1]]))
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), y*z])
>>> f.conjugate(matrix([[Integer(1),Integer(2),Integer(3)], [Integer(0),Integer(1),Integer(2)], [Integer(0),Integer(0),Integer(1)]]))
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + 4*x*y + 3*y^2 + 6*x*z + 9*y*z + 7*z^2 : y^2 + 2*y*z : y*z + 2*z^2)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, y*z])
f.conjugate(matrix([[1,2,3], [0,1,2], [0,0,1]]))
sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2+y^2, y^2])
sage: f.conjugate(matrix([[2,0], [0,1/2]]))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 1/8*y^2 : 1/2*y^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2)+y**Integer(2), y**Integer(2)])
>>> f.conjugate(matrix([[Integer(2),Integer(0)], [Integer(0),Integer(1)/Integer(2)]]))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 1/8*y^2 : 1/2*y^2)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2+y^2, y^2])
f.conjugate(matrix([[2,0], [0,1/2]]))
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2)+y**Integer(2), y**Integer(2)])
>>> f.conjugate(matrix([[Integer(2),Integer(0)], [Integer(0),Integer(1)/Integer(2)]]))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 + 1/8*y^2 : 1/2*y^2)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2+y^2, y^2])
f.conjugate(matrix([[2,0], [0,1/2]]))
sage: R.<x> = PolynomialRing(QQ)
sage: K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([1/3*x^2 + 1/2*y^2, y^2])
sage: f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1
 over Number Field in i with defining polynomial x^2 + 1
  Defn: Defined on coordinates by sending (x : y) to
        ((1/3*i)*x^2 + (1/2*i)*y^2 : (-i)*y^2)

>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1)/Integer(3)*x**Integer(2) + Integer(1)/Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.conjugate(matrix([[i,Integer(0)], [Integer(0),-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1
 over Number Field in i with defining polynomial x^2 + 1
  Defn: Defined on coordinates by sending (x : y) to
        ((1/3*i)*x^2 + (1/2*i)*y^2 : (-i)*y^2)

R.<x> = PolynomialRing(QQ)
K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([1/3*x^2 + 1/2*y^2, y^2])
f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field
>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1)/Integer(3)*x**Integer(2) + Integer(1)/Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.conjugate(matrix([[i,Integer(0)], [Integer(0),-i]]))                                  # needs sage.rings.number_field
Dynamical System of Projective Space of dimension 1
 over Number Field in i with defining polynomial x^2 + 1
  Defn: Defined on coordinates by sending (x : y) to
        ((1/3*i)*x^2 + (1/2*i)*y^2 : (-i)*y^2)

R.<x> = PolynomialRing(QQ)
K.<i> = NumberField(x^2 + 1)                                          # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([1/3*x^2 + 1/2*y^2, y^2])
f.conjugate(matrix([[i,0], [0,-i]]))                                  # needs sage.rings.number_field

Todo

Use the left and right action functionality to replace the code below with #return DynamicalSystem_projective(M.inverse()*self*M, domain=self.codomain()) once there is a function to pass to the smallest field of definition.

critical_height(**kwds)[source]

Compute the critical height of this dynamical system.

The critical height is defined by J. Silverman as the sum of the canonical heights of the critical points. This must be dimension 1 and defined over a number field or number field order.

The computations can be done either over the algebraic closure of the base field or over the minimal extension of the base field that contains the critical points.

INPUT: keyword arguments:

  • badprimes – (optional) a list of primes of bad reduction

  • N – (default: 10) positive integer; number of terms of the series to use in the local green functions

  • prec – (default: 100) positive integer, float point or \(p\)-adic precision

  • error_bound – (optional) a positive real number

  • use_algebraic_closure – boolean (default: True); if True, uses the algebraic closure. If False, uses the smallest extension of the base field containing all the critical points.

OUTPUT: real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 + 7*y^3, 11*y^3])
sage: f.critical_height()                                                   # needs sage.rings.number_field
1.1989273321156851418802151128

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(7)*y**Integer(3), Integer(11)*y**Integer(3)])
>>> f.critical_height()                                                   # needs sage.rings.number_field
1.1989273321156851418802151128

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 + 7*y^3, 11*y^3])
f.critical_height()                                                   # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(2)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + w*y^2, y^2])
sage: f.critical_height()
0.16090842452312941163719755472

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + w*y**Integer(2), y**Integer(2)])
>>> f.critical_height()
0.16090842452312941163719755472

# needs sage.rings.number_field
K.<w> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + w*y^2, y^2])
f.critical_height()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + w*y**Integer(2), y**Integer(2)])
>>> f.critical_height()
0.16090842452312941163719755472

# needs sage.rings.number_field
K.<w> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + w*y^2, y^2])
f.critical_height()

Postcritically finite maps have critical height 0:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 - 3/4*x*y^2 + 3/4*y^3, y^3])
sage: f.critical_height(error_bound=0.0001)                                 # needs sage.rings.number_field
0.00000000000000000000000000000

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(3)/Integer(4)*x*y**Integer(2) + Integer(3)/Integer(4)*y**Integer(3), y**Integer(3)])
>>> f.critical_height(error_bound=RealNumber('0.0001'))                                 # needs sage.rings.number_field
0.00000000000000000000000000000

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - 3/4*x*y^2 + 3/4*y^3, y^3])
f.critical_height(error_bound=0.0001)                                 # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 + 3*x*y^2, y^3])
sage: f.critical_height(use_algebraic_closure=False)                        # needs sage.rings.number_field
0.000023477016733897112886491967991
sage: f.critical_height()                                                   # needs sage.rings.number_field
0.000023477016733897112886491967991

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(3)*x*y**Integer(2), y**Integer(3)])
>>> f.critical_height(use_algebraic_closure=False)                        # needs sage.rings.number_field
0.000023477016733897112886491967991
>>> f.critical_height()                                                   # needs sage.rings.number_field
0.000023477016733897112886491967991

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 + 3*x*y^2, y^3])
f.critical_height(use_algebraic_closure=False)                        # needs sage.rings.number_field
f.critical_height()                                                   # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(3)*x*y**Integer(2), y**Integer(3)])
>>> f.critical_height(use_algebraic_closure=False)                        # needs sage.rings.number_field
0.000023477016733897112886491967991
>>> f.critical_height()                                                   # needs sage.rings.number_field
0.000023477016733897112886491967991

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 + 3*x*y^2, y^3])
f.critical_height(use_algebraic_closure=False)                        # needs sage.rings.number_field
f.critical_height()                                                   # needs sage.rings.number_field
critical_point_portrait(check=True, use_algebraic_closure=True)[source]

If this dynamical system is post-critically finite, return its critical point portrait.

This is the directed graph of iterates starting with the critical points. Must be dimension 1. If check is True, then the map is first checked to see if it is postcritically finite.

The computations can be done either over the algebraic closure of the base field or over the minimal extension of the base field that contains the critical points.

INPUT:

  • check – boolean (default: True)

  • use_algebraic_closure – boolean (default: True); if True, uses the algebraic closure. If False, uses the smallest extension of the base field containing all the critical points.

OUTPUT: a digraph

EXAMPLES:

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: K.<v> = NumberField(z^6 + 2*z^5 + 2*z^4 + 2*z^3 + z^2 + 1)
sage: PS.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + v*y^2, y^2])
sage: f.critical_point_portrait(check=False)        # long time             # needs sage.graphs
Looped digraph on 6 vertices

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(6) + Integer(2)*z**Integer(5) + Integer(2)*z**Integer(4) + Integer(2)*z**Integer(3) + z**Integer(2) + Integer(1), names=('v',)); (v,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + v*y**Integer(2), y**Integer(2)])
>>> f.critical_point_portrait(check=False)        # long time             # needs sage.graphs
Looped digraph on 6 vertices

# needs sage.rings.number_field
R.<z> = QQ[]
K.<v> = NumberField(z^6 + 2*z^5 + 2*z^4 + 2*z^3 + z^2 + 1)
PS.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + v*y^2, y^2])
f.critical_point_portrait(check=False)        # long time             # needs sage.graphs
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^5 + 5/4*x*y^4, y^5])
sage: f.critical_point_portrait(check=False)                                # needs sage.graphs sage.rings.number_field
Looped digraph on 5 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(5)/Integer(4)*x*y**Integer(4), y**Integer(5)])
>>> f.critical_point_portrait(check=False)                                # needs sage.graphs sage.rings.number_field
Looped digraph on 5 vertices

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^5 + 5/4*x*y^4, y^5])
f.critical_point_portrait(check=False)                                # needs sage.graphs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(5)/Integer(4)*x*y**Integer(4), y**Integer(5)])
>>> f.critical_point_portrait(check=False)                                # needs sage.graphs sage.rings.number_field
Looped digraph on 5 vertices

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^5 + 5/4*x*y^4, y^5])
f.critical_point_portrait(check=False)                                # needs sage.graphs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + 2*y^2, y^2])
sage: f.critical_point_portrait()                                           # needs sage.rings.number_field
Traceback (most recent call last):
...
TypeError: map must be post-critically finite

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.critical_point_portrait()                                           # needs sage.rings.number_field
Traceback (most recent call last):
...
TypeError: map must be post-critically finite

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + 2*y^2, y^2])
f.critical_point_portrait()                                           # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.critical_point_portrait()                                           # needs sage.rings.number_field
Traceback (most recent call last):
...
TypeError: map must be post-critically finite

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + 2*y^2, y^2])
f.critical_point_portrait()                                           # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: R.<t> = QQ[]
sage: K.<v> = NumberField(t^3 + 2*t^2 + t + 1)
sage: phi = K.embeddings(QQbar)[0]
sage: P.<x, y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 + v*y^2, y^2])
sage: f.change_ring(phi).critical_point_portrait()                          # needs sage.graphs
Looped digraph on 4 vertices

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['t']; (t,) = R._first_ngens(1)
>>> K = NumberField(t**Integer(3) + Integer(2)*t**Integer(2) + t + Integer(1), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = K.embeddings(QQbar)[Integer(0)]
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + v*y**Integer(2), y**Integer(2)])
>>> f.change_ring(phi).critical_point_portrait()                          # needs sage.graphs
Looped digraph on 4 vertices

# needs sage.rings.number_field
R.<t> = QQ[]
K.<v> = NumberField(t^3 + 2*t^2 + t + 1)
phi = K.embeddings(QQbar)[0]
P.<x, y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 + v*y^2, y^2])
f.change_ring(phi).critical_point_portrait()                          # needs sage.graphs
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['t']; (t,) = R._first_ngens(1)
>>> K = NumberField(t**Integer(3) + Integer(2)*t**Integer(2) + t + Integer(1), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = K.embeddings(QQbar)[Integer(0)]
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + v*y**Integer(2), y**Integer(2)])
>>> f.change_ring(phi).critical_point_portrait()                          # needs sage.graphs
Looped digraph on 4 vertices

# needs sage.rings.number_field
R.<t> = QQ[]
K.<v> = NumberField(t^3 + 2*t^2 + t + 1)
phi = K.embeddings(QQbar)[0]
P.<x, y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 + v*y^2, y^2])
f.change_ring(phi).critical_point_portrait()                          # needs sage.graphs
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
sage: f.critical_point_portrait(use_algebraic_closure=False)  # long time
Looped digraph on 6 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.critical_point_portrait(use_algebraic_closure=False)  # long time
Looped digraph on 6 vertices

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.critical_point_portrait(use_algebraic_closure=False)  # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.critical_point_portrait(use_algebraic_closure=False)  # long time
Looped digraph on 6 vertices

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.critical_point_portrait(use_algebraic_closure=False)  # long time
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar,1)
sage: f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
sage: f.critical_point_portrait()   # long time                             # needs sage.graphs
Looped digraph on 6 vertices

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.critical_point_portrait()   # long time                             # needs sage.graphs
Looped digraph on 6 vertices

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.critical_point_portrait()   # long time                             # needs sage.graphs
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.critical_point_portrait()   # long time                             # needs sage.graphs
Looped digraph on 6 vertices

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.critical_point_portrait()   # long time                             # needs sage.graphs
sage: P.<x,y> = ProjectiveSpace(GF(3),1)
sage: f = DynamicalSystem_projective([x^2 + x*y - y^2, x*y])
sage: f.critical_point_portrait(use_algebraic_closure=False)                # needs sage.libs.pari
Looped digraph on 6 vertices
sage: f.critical_point_portrait() #long time
Looped digraph on 6 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y - y**Integer(2), x*y])
>>> f.critical_point_portrait(use_algebraic_closure=False)                # needs sage.libs.pari
Looped digraph on 6 vertices
>>> f.critical_point_portrait() #long time
Looped digraph on 6 vertices

P.<x,y> = ProjectiveSpace(GF(3),1)
f = DynamicalSystem_projective([x^2 + x*y - y^2, x*y])
f.critical_point_portrait(use_algebraic_closure=False)                # needs sage.libs.pari
f.critical_point_portrait() #long time
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y - y**Integer(2), x*y])
>>> f.critical_point_portrait(use_algebraic_closure=False)                # needs sage.libs.pari
Looped digraph on 6 vertices
>>> f.critical_point_portrait() #long time
Looped digraph on 6 vertices

P.<x,y> = ProjectiveSpace(GF(3),1)
f = DynamicalSystem_projective([x^2 + x*y - y^2, x*y])
f.critical_point_portrait(use_algebraic_closure=False)                # needs sage.libs.pari
f.critical_point_portrait() #long time
critical_points(R=None)[source]

Return the critical points of this dynamical system defined over the ring \(R\) or the base ring of this map.

Must be dimension 1.

INPUT:

  • R – (optional) a ring

OUTPUT: list of projective space points defined over \(R\)

EXAMPLES:

sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
sage: f.critical_points()                                                   # needs sage.rings.function_field
[(1 : 0)]
sage: K.<w> = QuadraticField(6)                                             # needs sage.rings.number_field
sage: f.critical_points(K)                                                  # needs sage.rings.number_field
[(-1/3*w : 1), (1/3*w : 1), (1 : 0)]

>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(2)*x*y**Integer(2) + Integer(2)*y**Integer(3), y**Integer(3)])
>>> f.critical_points()                                                   # needs sage.rings.function_field
[(1 : 0)]
>>> K = QuadraticField(Integer(6), names=('w',)); (w,) = K._first_ngens(1)# needs sage.rings.number_field
>>> f.critical_points(K)                                                  # needs sage.rings.number_field
[(-1/3*w : 1), (1/3*w : 1), (1 : 0)]

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
f.critical_points()                                                   # needs sage.rings.function_field
K.<w> = QuadraticField(6)                                             # needs sage.rings.number_field
f.critical_points(K)                                                  # needs sage.rings.number_field
sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
sage: f.critical_points(QQbar)                                              # needs sage.rings.number_field
[(-0.7071067811865475?*I : 1), (0.7071067811865475?*I : 1)]

>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y])
>>> f.critical_points(QQbar)                                              # needs sage.rings.number_field
[(-0.7071067811865475?*I : 1), (0.7071067811865475?*I : 1)]

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
f.critical_points(QQbar)                                              # needs sage.rings.number_field
>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y])
>>> f.critical_points(QQbar)                                              # needs sage.rings.number_field
[(-0.7071067811865475?*I : 1), (0.7071067811865475?*I : 1)]

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
f.critical_points(QQbar)                                              # needs sage.rings.number_field
critical_subscheme()[source]

Return the critical subscheme of this dynamical system.

OUTPUT: projective subscheme

EXAMPLES:

sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
sage: f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Rational Field
defined by:
  9*x^2*y^2 - 6*y^4

>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(2)*x*y**Integer(2) + Integer(2)*y**Integer(3), y**Integer(3)])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Rational Field
defined by:
  9*x^2*y^2 - 6*y^4

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
f.critical_subscheme()                                                # needs sage.rings.function_field
sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
sage: f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Rational Field
defined by:
  4*x^2 + 2*y^2

>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Rational Field
defined by:
  4*x^2 + 2*y^2

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
f.critical_subscheme()                                                # needs sage.rings.function_field
>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Rational Field
defined by:
  4*x^2 + 2*y^2

set_verbose(None)
P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y])
f.critical_subscheme()                                                # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([2*x^2 - y^2, x*y, z^2])
sage: f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  8*x^2*z + 4*y^2*z

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y, z**Integer(2)])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  8*x^2*z + 4*y^2*z

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y, z^2])
f.critical_subscheme()                                                # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), x*y, z**Integer(2)])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  8*x^2*z + 4*y^2*z

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([2*x^2 - y^2, x*y, z^2])
f.critical_subscheme()                                                # needs sage.rings.function_field
sage: # needs sage.rings.finite_rings
sage: P.<x,y,z,w> = ProjectiveSpace(GF(81), 3)
sage: g = DynamicalSystem_projective([x^3 + y^3, y^3 + z^3, z^3 + x^3, w^3])
sage: g.critical_subscheme()
Closed subscheme of Projective Space of dimension 3 over Finite Field in
z4 of size 3^4 defined by:
  0

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(81)), Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> g = DynamicalSystem_projective([x**Integer(3) + y**Integer(3), y**Integer(3) + z**Integer(3), z**Integer(3) + x**Integer(3), w**Integer(3)])
>>> g.critical_subscheme()
Closed subscheme of Projective Space of dimension 3 over Finite Field in
z4 of size 3^4 defined by:
  0

# needs sage.rings.finite_rings
P.<x,y,z,w> = ProjectiveSpace(GF(81), 3)
g = DynamicalSystem_projective([x^3 + y^3, y^3 + z^3, z^3 + x^3, w^3])
g.critical_subscheme()
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(81)), Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> g = DynamicalSystem_projective([x**Integer(3) + y**Integer(3), y**Integer(3) + z**Integer(3), z**Integer(3) + x**Integer(3), w**Integer(3)])
>>> g.critical_subscheme()
Closed subscheme of Projective Space of dimension 3 over Finite Field in
z4 of size 3^4 defined by:
  0

# needs sage.rings.finite_rings
P.<x,y,z,w> = ProjectiveSpace(GF(81), 3)
g = DynamicalSystem_projective([x^3 + y^3, y^3 + z^3, z^3 + x^3, w^3])
g.critical_subscheme()
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2, x*y])
sage: f.critical_subscheme()                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: the function is not a morphism

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: the function is not a morphism

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2, x*y])
f.critical_subscheme()                                                # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y])
>>> f.critical_subscheme()                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: the function is not a morphism

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2, x*y])
f.critical_subscheme()                                                # needs sage.rings.function_field
degree_sequence(iterates=2)[source]

Return sequence of degrees of normalized iterates starting with the degree of this dynamical system.

INPUT:

  • iterates – (default: 2) positive integer

OUTPUT: list of integers

EXAMPLES:

sage: P2.<X,Y,Z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([Z^2, X*Y, Y^2])
sage: f.degree_sequence(15)                                                 # needs sage.rings.function_field
[2, 3, 5, 8, 11, 17, 24, 31, 45, 56, 68, 91, 93, 184, 275]

>>> from sage.all import *
>>> P2 = ProjectiveSpace(QQ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([Z**Integer(2), X*Y, Y**Integer(2)])
>>> f.degree_sequence(Integer(15))                                                 # needs sage.rings.function_field
[2, 3, 5, 8, 11, 17, 24, 31, 45, 56, 68, 91, 93, 184, 275]

P2.<X,Y,Z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([Z^2, X*Y, Y^2])
f.degree_sequence(15)                                                 # needs sage.rings.function_field
sage: F.<t> = PolynomialRing(QQ)
sage: P2.<X,Y,Z> = ProjectiveSpace(F, 2)
sage: f = DynamicalSystem_projective([Y*Z, X*Y, Y^2 + t*X*Z])
sage: f.degree_sequence(5)                                                  # needs sage.rings.function_field
[2, 3, 5, 8, 13]

>>> from sage.all import *
>>> F = PolynomialRing(QQ, names=('t',)); (t,) = F._first_ngens(1)
>>> P2 = ProjectiveSpace(F, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([Y*Z, X*Y, Y**Integer(2) + t*X*Z])
>>> f.degree_sequence(Integer(5))                                                  # needs sage.rings.function_field
[2, 3, 5, 8, 13]

F.<t> = PolynomialRing(QQ)
P2.<X,Y,Z> = ProjectiveSpace(F, 2)
f = DynamicalSystem_projective([Y*Z, X*Y, Y^2 + t*X*Z])
f.degree_sequence(5)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> F = PolynomialRing(QQ, names=('t',)); (t,) = F._first_ngens(1)
>>> P2 = ProjectiveSpace(F, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([Y*Z, X*Y, Y**Integer(2) + t*X*Z])
>>> f.degree_sequence(Integer(5))                                                  # needs sage.rings.function_field
[2, 3, 5, 8, 13]

F.<t> = PolynomialRing(QQ)
P2.<X,Y,Z> = ProjectiveSpace(F, 2)
f = DynamicalSystem_projective([Y*Z, X*Y, Y^2 + t*X*Z])
f.degree_sequence(5)                                                  # needs sage.rings.function_field
sage: P2.<X,Y,Z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([X^2, Y^2, Z^2])
sage: f.degree_sequence(10)                                                 # needs sage.rings.function_field
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

>>> from sage.all import *
>>> P2 = ProjectiveSpace(QQ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X**Integer(2), Y**Integer(2), Z**Integer(2)])
>>> f.degree_sequence(Integer(10))                                                 # needs sage.rings.function_field
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

P2.<X,Y,Z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([X^2, Y^2, Z^2])
f.degree_sequence(10)                                                 # needs sage.rings.function_field
>>> from sage.all import *
>>> P2 = ProjectiveSpace(QQ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X**Integer(2), Y**Integer(2), Z**Integer(2)])
>>> f.degree_sequence(Integer(10))                                                 # needs sage.rings.function_field
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

P2.<X,Y,Z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([X^2, Y^2, Z^2])
f.degree_sequence(10)                                                 # needs sage.rings.function_field
sage: P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
sage: f = DynamicalSystem_projective([X*Y, Y*Z+Z^2, Z^2])
sage: f.degree_sequence(10)                                                 # needs sage.rings.function_field
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

>>> from sage.all import *
>>> P2 = ProjectiveSpace(ZZ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X*Y, Y*Z+Z**Integer(2), Z**Integer(2)])
>>> f.degree_sequence(Integer(10))                                                 # needs sage.rings.function_field
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem_projective([X*Y, Y*Z+Z^2, Z^2])
f.degree_sequence(10)                                                 # needs sage.rings.function_field
>>> from sage.all import *
>>> P2 = ProjectiveSpace(ZZ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X*Y, Y*Z+Z**Integer(2), Z**Integer(2)])
>>> f.degree_sequence(Integer(10))                                                 # needs sage.rings.function_field
[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem_projective([X*Y, Y*Z+Z^2, Z^2])
f.degree_sequence(10)                                                 # needs sage.rings.function_field
dehomogenize(n)[source]

Return the standard dehomogenization at the n[0] coordinate for the domain and the n[1] coordinate for the codomain.

Note that the new function is defined over the fraction field of the base ring of this map.

INPUT:

  • n – tuple of nonnegative integers; if n is an integer, then the two values of the tuple are assumed to be the same

OUTPUT:

If the dehomogenizing indices are the same for the domain and codomain, then a DynamicalSystem_affine given by dehomogenizing the source and target of self with respect to the given indices is returned. If the dehomogenizing indices for the domain and codomain are different then the resulting affine patches are different and a scheme morphism is returned.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.dehomogenize(0)
Dynamical System of Affine Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (y) to
        (y^2/(y^2 + 1))
sage: f.dehomogenize((0, 1))
Scheme morphism:
  From: Affine Space of dimension 1 over Integer Ring
  To:   Affine Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (y) to
        ((y^2 + 1)/y^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.dehomogenize(Integer(0))
Dynamical System of Affine Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (y) to
        (y^2/(y^2 + 1))
>>> f.dehomogenize((Integer(0), Integer(1)))
Scheme morphism:
  From: Affine Space of dimension 1 over Integer Ring
  To:   Affine Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (y) to
        ((y^2 + 1)/y^2)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.dehomogenize(0)
f.dehomogenize((0, 1))
dynamical_degree(N=3, prec=53)[source]

Return an approximation to the dynamical degree of this dynamical system. The dynamical degree is defined as \(\lim_{n \to \infty} \sqrt[n]{\deg(f^n)}\).

INPUT:

  • N – (default: 3) positive integer, iterate to use for approximation

  • prec – (default: 53) positive integer, real precision to use when computing root

OUTPUT: real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y, y^2])
sage: f.dynamical_degree()                                                  # needs sage.rings.function_field
2.00000000000000

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> f.dynamical_degree()                                                  # needs sage.rings.function_field
2.00000000000000

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
f.dynamical_degree()                                                  # needs sage.rings.function_field
sage: P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
sage: f = DynamicalSystem_projective([X*Y, Y*Z + Z^2, Z^2])
sage: f.dynamical_degree(N=5, prec=100)                                     # needs sage.rings.function_field
1.4309690811052555010452244131

>>> from sage.all import *
>>> P2 = ProjectiveSpace(ZZ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X*Y, Y*Z + Z**Integer(2), Z**Integer(2)])
>>> f.dynamical_degree(N=Integer(5), prec=Integer(100))                                     # needs sage.rings.function_field
1.4309690811052555010452244131

P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem_projective([X*Y, Y*Z + Z^2, Z^2])
f.dynamical_degree(N=5, prec=100)                                     # needs sage.rings.function_field
>>> from sage.all import *
>>> P2 = ProjectiveSpace(ZZ, Integer(2), names=('X', 'Y', 'Z',)); (X, Y, Z,) = P2._first_ngens(3)
>>> f = DynamicalSystem_projective([X*Y, Y*Z + Z**Integer(2), Z**Integer(2)])
>>> f.dynamical_degree(N=Integer(5), prec=Integer(100))                                     # needs sage.rings.function_field
1.4309690811052555010452244131

P2.<X,Y,Z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem_projective([X*Y, Y*Z + Z^2, Z^2])
f.dynamical_degree(N=5, prec=100)                                     # needs sage.rings.function_field
dynatomic_polynomial(period)[source]

For a dynamical system of \(\mathbb{P}^1\) compute the dynatomic polynomial.

The dynatomic polynomial is the analog of the cyclotomic polynomial and its roots are the points of formal period \(period\). If possible the division is done in the coordinate ring of this map and a polynomial is returned. In rings where that is not possible, a FractionField element will be returned. In certain cases, when the conversion back to a polynomial fails, a SymbolRing element will be returned.

ALGORITHM:

For a positive integer \(n\), let \([F_n,G_n]\) be the coordinates of the \(n\)-th iterate of \(f\). Then construct

\[\Phi^{\ast}_n(f)(x,y) = \sum_{d \mid n} (yF_d(x,y) - xG_d(x,y))^{\mu(n/d)},\]

where \(\mu\) is the Möbius function.

For a pair \([m,n]\), let \(f^m = [F_m,G_m]\). Compute

\[\Phi^{\ast}_{m,n}(f)(x,y) = \Phi^{\ast}_n(f)(F_m,G_m) / \Phi^{\ast}_n(f)(F_{m-1},G_{m-1})\]

REFERENCES:

INPUT:

  • period – positive integer or a list/tuple \([m,n]\) where \(m\) is the preperiod and \(n\) is the period

OUTPUT:

If possible, a two variable polynomial in the coordinate ring of this map. Otherwise a fraction field element of the coordinate ring of this map. Or, a SymbolicRing element.

Todo

  • Do the division when the base ring is \(p\)-adic so that the output is a polynomial.

  • Convert back to a polynomial when the base ring is a function field (not over \(\QQ\) or \(F_p\)).

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
x^2 + x*y + 2*y^2

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + 2*y^2

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: f.dynatomic_polynomial(4)                                             # needs sage.libs.pari
2*x^12 + 18*x^10*y^2 + 57*x^8*y^4 + 79*x^6*y^6 + 48*x^4*y^8 + 12*x^2*y^10 + y^12

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.dynatomic_polynomial(Integer(4))                                             # needs sage.libs.pari
2*x^12 + 18*x^10*y^2 + 57*x^8*y^4 + 79*x^6*y^6 + 48*x^4*y^8 + 12*x^2*y^10 + y^12

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.dynatomic_polynomial(4)                                             # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.dynatomic_polynomial(Integer(4))                                             # needs sage.libs.pari
2*x^12 + 18*x^10*y^2 + 57*x^8*y^4 + 79*x^6*y^6 + 48*x^4*y^8 + 12*x^2*y^10 + y^12

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.dynatomic_polynomial(4)                                             # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(CC,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 3*x*y])
sage: f.dynatomic_polynomial(3)                                             # needs sage.libs.pari
13.0000000000000*x^6 + 117.000000000000*x^4*y^2 +
78.0000000000000*x^2*y^4 + y^6

>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(3)*x*y])
>>> f.dynatomic_polynomial(Integer(3))                                             # needs sage.libs.pari
13.0000000000000*x^6 + 117.000000000000*x^4*y^2 +
78.0000000000000*x^2*y^4 + y^6

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^2 + y^2, 3*x*y])
f.dynatomic_polynomial(3)                                             # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(3)*x*y])
>>> f.dynatomic_polynomial(Integer(3))                                             # needs sage.libs.pari
13.0000000000000*x^6 + 117.000000000000*x^4*y^2 +
78.0000000000000*x^2*y^4 + y^6

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^2 + y^2, 3*x*y])
f.dynatomic_polynomial(3)                                             # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - 10/9*y^2, y^2])
sage: f.dynatomic_polynomial([2,1])
x^4*y^2 - 11/9*x^2*y^4 - 80/81*y^6

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(10)/Integer(9)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(2),Integer(1)])
x^4*y^2 - 11/9*x^2*y^4 - 80/81*y^6

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 10/9*y^2, y^2])
f.dynatomic_polynomial([2,1])
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(10)/Integer(9)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(2),Integer(1)])
x^4*y^2 - 11/9*x^2*y^4 - 80/81*y^6

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 10/9*y^2, y^2])
f.dynatomic_polynomial([2,1])
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
sage: f.dynatomic_polynomial([2,3])                                         # needs sage.libs.pari
x^12 - 95/8*x^10*y^2 + 13799/256*x^8*y^4 - 119953/1024*x^6*y^6 +
8198847/65536*x^4*y^8 - 31492431/524288*x^2*y^10 +
172692729/16777216*y^12

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(2),Integer(3)])                                         # needs sage.libs.pari
x^12 - 95/8*x^10*y^2 + 13799/256*x^8*y^4 - 119953/1024*x^6*y^6 +
8198847/65536*x^4*y^8 - 31492431/524288*x^2*y^10 +
172692729/16777216*y^12

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.dynatomic_polynomial([2,3])                                         # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(2),Integer(3)])                                         # needs sage.libs.pari
x^12 - 95/8*x^10*y^2 + 13799/256*x^8*y^4 - 119953/1024*x^6*y^6 +
8198847/65536*x^4*y^8 - 31492431/524288*x^2*y^10 +
172692729/16777216*y^12

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.dynatomic_polynomial([2,3])                                         # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.dynatomic_polynomial([1,2])                                         # needs sage.libs.pari
x^2 - x*y

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(1),Integer(2)])                                         # needs sage.libs.pari
x^2 - x*y

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.dynatomic_polynomial([1,2])                                         # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(1),Integer(2)])                                         # needs sage.libs.pari
x^2 - x*y

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.dynatomic_polynomial([1,2])                                         # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 - y^3, 3*x*y^2])
sage: f.dynatomic_polynomial([0,4])==f.dynatomic_polynomial(4)              # needs sage.libs.pari
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - y**Integer(3), Integer(3)*x*y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(0),Integer(4)])==f.dynatomic_polynomial(Integer(4))              # needs sage.libs.pari
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - y^3, 3*x*y^2])
f.dynatomic_polynomial([0,4])==f.dynatomic_polynomial(4)              # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - y**Integer(3), Integer(3)*x*y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(0),Integer(4)])==f.dynatomic_polynomial(Integer(4))              # needs sage.libs.pari
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - y^3, 3*x*y^2])
f.dynatomic_polynomial([0,4])==f.dynatomic_polynomial(4)              # needs sage.libs.pari
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y, z^2])
sage: f.dynatomic_polynomial(2)
Traceback (most recent call last):
...
TypeError: does not make sense in dimension >1

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y, z**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))
Traceback (most recent call last):
...
TypeError: does not make sense in dimension >1

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2 + y^2, x*y, z^2])
f.dynatomic_polynomial(2)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y, z**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))
Traceback (most recent call last):
...
TypeError: does not make sense in dimension >1

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2 + y^2, x*y, z^2])
f.dynatomic_polynomial(2)
sage: P.<x,y> = ProjectiveSpace(Qp(5),1)                                    # needs sage.rings.padics
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])                      # needs sage.rings.padics
sage: f.dynatomic_polynomial(2)                                             # needs sage.rings.padics
(x^4*y + (2 + O(5^20))*x^2*y^3 - x*y^4 + (2 + O(5^20))*y^5)/(x^2*y - x*y^2 + y^3)

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(5)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)# needs sage.rings.padics
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])                      # needs sage.rings.padics
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.rings.padics
(x^4*y + (2 + O(5^20))*x^2*y^3 - x*y^4 + (2 + O(5^20))*y^5)/(x^2*y - x*y^2 + y^3)

P.<x,y> = ProjectiveSpace(Qp(5),1)                                    # needs sage.rings.padics
f = DynamicalSystem_projective([x^2 + y^2, y^2])                      # needs sage.rings.padics
f.dynatomic_polynomial(2)                                             # needs sage.rings.padics
>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(5)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)# needs sage.rings.padics
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])                      # needs sage.rings.padics
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.rings.padics
(x^4*y + (2 + O(5^20))*x^2*y^3 - x*y^4 + (2 + O(5^20))*y^5)/(x^2*y - x*y^2 + y^3)

P.<x,y> = ProjectiveSpace(Qp(5),1)                                    # needs sage.rings.padics
f = DynamicalSystem_projective([x^2 + y^2, y^2])                      # needs sage.rings.padics
f.dynatomic_polynomial(2)                                             # needs sage.rings.padics
sage: L.<t> = PolynomialRing(QQ)
sage: P.<x,y> = ProjectiveSpace(L,1)
sage: f = DynamicalSystem_projective([x^2 + t*y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
x^2 + x*y + (t + 1)*y^2

>>> from sage.all import *
>>> L = PolynomialRing(QQ, names=('t',)); (t,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + t*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + (t + 1)*y^2

L.<t> = PolynomialRing(QQ)
P.<x,y> = ProjectiveSpace(L,1)
f = DynamicalSystem_projective([x^2 + t*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
>>> from sage.all import *
>>> L = PolynomialRing(QQ, names=('t',)); (t,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + t*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + (t + 1)*y^2

L.<t> = PolynomialRing(QQ)
P.<x,y> = ProjectiveSpace(L,1)
f = DynamicalSystem_projective([x^2 + t*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
sage: K.<c> = PolynomialRing(ZZ)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
sage: f.dynatomic_polynomial([1, 2])                                        # needs sage.libs.pari
x^2 - x*y + (c + 1)*y^2

>>> from sage.all import *
>>> K = PolynomialRing(ZZ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(1), Integer(2)])                                        # needs sage.libs.pari
x^2 - x*y + (c + 1)*y^2

K.<c> = PolynomialRing(ZZ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.dynatomic_polynomial([1, 2])                                        # needs sage.libs.pari
>>> from sage.all import *
>>> K = PolynomialRing(ZZ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(1), Integer(2)])                                        # needs sage.libs.pari
x^2 - x*y + (c + 1)*y^2

K.<c> = PolynomialRing(ZZ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.dynatomic_polynomial([1, 2])                                        # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
x^2 + x*y + 2*y^2
sage: R.<X> = PolynomialRing(QQ)
sage: K.<c> = NumberField(X^2 + X + 2)                                      # needs sage.rings.number_field
sage: PP = P.change_ring(K)
sage: ff = f.change_ring(K)
sage: p = PP((c, 1))
sage: ff(ff(p)) == p
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + 2*y^2
>>> R = PolynomialRing(QQ, names=('X',)); (X,) = R._first_ngens(1)
>>> K = NumberField(X**Integer(2) + X + Integer(2), names=('c',)); (c,) = K._first_ngens(1)# needs sage.rings.number_field
>>> PP = P.change_ring(K)
>>> ff = f.change_ring(K)
>>> p = PP((c, Integer(1)))
>>> ff(ff(p)) == p
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
R.<X> = PolynomialRing(QQ)
K.<c> = NumberField(X^2 + X + 2)                                      # needs sage.rings.number_field
PP = P.change_ring(K)
ff = f.change_ring(K)
p = PP((c, 1))
ff(ff(p)) == p
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + 2*y^2
>>> R = PolynomialRing(QQ, names=('X',)); (X,) = R._first_ngens(1)
>>> K = NumberField(X**Integer(2) + X + Integer(2), names=('c',)); (c,) = K._first_ngens(1)# needs sage.rings.number_field
>>> PP = P.change_ring(K)
>>> ff = f.change_ring(K)
>>> p = PP((c, Integer(1)))
>>> ff(ff(p)) == p
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
R.<X> = PolynomialRing(QQ)
K.<c> = NumberField(X^2 + X + 2)                                      # needs sage.rings.number_field
PP = P.change_ring(K)
ff = f.change_ring(K)
p = PP((c, 1))
ff(ff(p)) == p
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: f.dynatomic_polynomial([2, 2])                                        # needs sage.libs.pari
x^4 + 4*x^2*y^2 + y^4
sage: R.<X> = PolynomialRing(QQ)
sage: K.<c> = NumberField(X^4 + 4*X^2 + 1)                                  # needs sage.rings.number_field
sage: PP = P.change_ring(K)
sage: ff = f.change_ring(K)
sage: p = PP((c, 1))
sage: ff.nth_iterate(p, 4) == ff.nth_iterate(p, 2)                          # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.dynatomic_polynomial([Integer(2), Integer(2)])                                        # needs sage.libs.pari
x^4 + 4*x^2*y^2 + y^4
>>> R = PolynomialRing(QQ, names=('X',)); (X,) = R._first_ngens(1)
>>> K = NumberField(X**Integer(4) + Integer(4)*X**Integer(2) + Integer(1), names=('c',)); (c,) = K._first_ngens(1)# needs sage.rings.number_field
>>> PP = P.change_ring(K)
>>> ff = f.change_ring(K)
>>> p = PP((c, Integer(1)))
>>> ff.nth_iterate(p, Integer(4)) == ff.nth_iterate(p, Integer(2))                          # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.dynatomic_polynomial([2, 2])                                        # needs sage.libs.pari
R.<X> = PolynomialRing(QQ)
K.<c> = NumberField(X^4 + 4*X^2 + 1)                                  # needs sage.rings.number_field
PP = P.change_ring(K)
ff = f.change_ring(K)
p = PP((c, 1))
ff.nth_iterate(p, 4) == ff.nth_iterate(p, 2)                          # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.dynatomic_polynomial([Integer(2), Integer(2)])                                        # needs sage.libs.pari
x^4 + 4*x^2*y^2 + y^4
>>> R = PolynomialRing(QQ, names=('X',)); (X,) = R._first_ngens(1)
>>> K = NumberField(X**Integer(4) + Integer(4)*X**Integer(2) + Integer(1), names=('c',)); (c,) = K._first_ngens(1)# needs sage.rings.number_field
>>> PP = P.change_ring(K)
>>> ff = f.change_ring(K)
>>> p = PP((c, Integer(1)))
>>> ff.nth_iterate(p, Integer(4)) == ff.nth_iterate(p, Integer(2))                          # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.dynatomic_polynomial([2, 2])                                        # needs sage.libs.pari
R.<X> = PolynomialRing(QQ)
K.<c> = NumberField(X^4 + 4*X^2 + 1)                                  # needs sage.rings.number_field
PP = P.change_ring(K)
ff = f.change_ring(K)
p = PP((c, 1))
ff.nth_iterate(p, 4) == ff.nth_iterate(p, 2)                          # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(CC, 1)
sage: f = DynamicalSystem_projective([x^2 - CC.0/3*y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
(x^4*y + (-0.666666666666667*I)*x^2*y^3 - x*y^4
 + (-0.111111111111111 - 0.333333333333333*I)*y^5)/(x^2*y - x*y^2
                                                     + (-0.333333333333333*I)*y^3)

>>> from sage.all import *
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - CC.gen(0)/Integer(3)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
(x^4*y + (-0.666666666666667*I)*x^2*y^3 - x*y^4
 + (-0.111111111111111 - 0.333333333333333*I)*y^5)/(x^2*y - x*y^2
                                                     + (-0.333333333333333*I)*y^3)

P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^2 - CC.0/3*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - CC.gen(0)/Integer(3)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
(x^4*y + (-0.666666666666667*I)*x^2*y^3 - x*y^4
 + (-0.111111111111111 - 0.333333333333333*I)*y^5)/(x^2*y - x*y^2
                                                     + (-0.333333333333333*I)*y^3)

P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^2 - CC.0/3*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(CC, 1)
sage: f = DynamicalSystem_projective([x^2 - CC.0/5*y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
x^2 + x*y + (1.00000000000000 - 0.200000000000000*I)*y^2

>>> from sage.all import *
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - CC.gen(0)/Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + (1.00000000000000 - 0.200000000000000*I)*y^2

P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^2 - CC.0/5*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - CC.gen(0)/Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari
x^2 + x*y + (1.00000000000000 - 0.200000000000000*I)*y^2

P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^2 - CC.0/5*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari
sage: L.<t> = PolynomialRing(QuadraticField(2).maximal_order())             # needs sage.rings.number_field
sage: P.<x, y> = ProjectiveSpace(L.fraction_field(), 1)
sage: f = DynamicalSystem_projective([x^2 + (t^2 + 1)*y^2, y^2])
sage: f.dynatomic_polynomial(2)                                             # needs sage.libs.pari sage.rings.number_field
x^2 + x*y + (t^2 + 2)*y^2

>>> from sage.all import *
>>> L = PolynomialRing(QuadraticField(Integer(2)).maximal_order(), names=('t',)); (t,) = L._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(L.fraction_field(), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + (t**Integer(2) + Integer(1))*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari sage.rings.number_field
x^2 + x*y + (t^2 + 2)*y^2

L.<t> = PolynomialRing(QuadraticField(2).maximal_order())             # needs sage.rings.number_field
P.<x, y> = ProjectiveSpace(L.fraction_field(), 1)
f = DynamicalSystem_projective([x^2 + (t^2 + 1)*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari sage.rings.number_field
>>> from sage.all import *
>>> L = PolynomialRing(QuadraticField(Integer(2)).maximal_order(), names=('t',)); (t,) = L._first_ngens(1)# needs sage.rings.number_field
>>> P = ProjectiveSpace(L.fraction_field(), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + (t**Integer(2) + Integer(1))*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial(Integer(2))                                             # needs sage.libs.pari sage.rings.number_field
x^2 + x*y + (t^2 + 2)*y^2

L.<t> = PolynomialRing(QuadraticField(2).maximal_order())             # needs sage.rings.number_field
P.<x, y> = ProjectiveSpace(L.fraction_field(), 1)
f = DynamicalSystem_projective([x^2 + (t^2 + 1)*y^2, y^2])
f.dynatomic_polynomial(2)                                             # needs sage.libs.pari sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(ZZ, 1)
sage: f = DynamicalSystem_projective([x^2 - 5*y^2, y^2])
sage: f.dynatomic_polynomial([3,0 ])
0

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(3),Integer(0) ])
0

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 - 5*y^2, y^2])
f.dynatomic_polynomial([3,0 ])
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.dynatomic_polynomial([Integer(3),Integer(0) ])
0

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 - 5*y^2, y^2])
f.dynatomic_polynomial([3,0 ])
green_function(P, v, **kwds)[source]

Evaluate the local Green’s function at the place v for P with N terms of the series or to within a given error bound.

Must be over a number field or order of a number field. Note that this is the absolute local Green’s function so is scaled by the degree of the base field.

Use v=0 for the archimedean place over \(\QQ\) or field embedding. Non-archimedean places are prime ideals for number fields or primes over \(\QQ\).

ALGORITHM:

See Exercise 5.29 and Figure 5.6 of [Sil2007].

INPUT:

  • P – a projective point

  • v – nonnegative integer; a place, use 0 for the archimedean place

kwds:

  • N – (default: 10) positive integer; number of terms of the series to use

  • prec – (default: 100) positive integer, float point or \(p\)-adic precision

  • error_bound – (optional) a positive real number

OUTPUT: a real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y]);
sage: Q = P(5, 1)
sage: f.green_function(Q, 0, N=30)
1.6460930159932946233759277576

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y]);
>>> Q = P(Integer(5), Integer(1))
>>> f.green_function(Q, Integer(0), N=Integer(30))
1.6460930159932946233759277576

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y]);
Q = P(5, 1)
f.green_function(Q, 0, N=30)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y]);
sage: Q = P(5, 1)
sage: f.green_function(Q, 0, N=200, prec=200)
1.6460930160038721802875250367738355497198064992657997569827

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y]);
>>> Q = P(Integer(5), Integer(1))
>>> f.green_function(Q, Integer(0), N=Integer(200), prec=Integer(200))
1.6460930160038721802875250367738355497198064992657997569827

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y]);
Q = P(5, 1)
f.green_function(Q, 0, N=200, prec=200)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y]);
>>> Q = P(Integer(5), Integer(1))
>>> f.green_function(Q, Integer(0), N=Integer(200), prec=Integer(200))
1.6460930160038721802875250367738355497198064992657997569827

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y]);
Q = P(5, 1)
f.green_function(Q, 0, N=200, prec=200)
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(3)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([17*x^2 + 1/7*y^2, 17*w*x*y])
sage: f.green_function(P.point([w, 2], False), K.places()[1])
1.7236334013785676107373093775
sage: f.green_function(P([2, 1]), K.ideal(7), N=7)
0.48647753726382832627633818586
sage: f.green_function(P([w, 1]), K.ideal(17), error_bound=0.001)
-0.70813041039490996737374178059

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(17)*x**Integer(2) + Integer(1)/Integer(7)*y**Integer(2), Integer(17)*w*x*y])
>>> f.green_function(P.point([w, Integer(2)], False), K.places()[Integer(1)])
1.7236334013785676107373093775
>>> f.green_function(P([Integer(2), Integer(1)]), K.ideal(Integer(7)), N=Integer(7))
0.48647753726382832627633818586
>>> f.green_function(P([w, Integer(1)]), K.ideal(Integer(17)), error_bound=RealNumber('0.001'))
-0.70813041039490996737374178059

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([17*x^2 + 1/7*y^2, 17*w*x*y])
f.green_function(P.point([w, 2], False), K.places()[1])
f.green_function(P([2, 1]), K.ideal(7), N=7)
f.green_function(P([w, 1]), K.ideal(17), error_bound=0.001)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(17)*x**Integer(2) + Integer(1)/Integer(7)*y**Integer(2), Integer(17)*w*x*y])
>>> f.green_function(P.point([w, Integer(2)], False), K.places()[Integer(1)])
1.7236334013785676107373093775
>>> f.green_function(P([Integer(2), Integer(1)]), K.ideal(Integer(7)), N=Integer(7))
0.48647753726382832627633818586
>>> f.green_function(P([w, Integer(1)]), K.ideal(Integer(17)), error_bound=RealNumber('0.001'))
-0.70813041039490996737374178059

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([17*x^2 + 1/7*y^2, 17*w*x*y])
f.green_function(P.point([w, 2], False), K.places()[1])
f.green_function(P([2, 1]), K.ideal(7), N=7)
f.green_function(P([w, 1]), K.ideal(17), error_bound=0.001)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: f.green_function(P.point([5,2], False), 0, N=30)
1.7315451844777407992085512000
sage: f.green_function(P.point([2,1], False), 0, N=30)
0.86577259223181088325226209926
sage: f.green_function(P.point([1,1], False), 0, N=30)
0.43288629610862338612700146098

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.green_function(P.point([Integer(5),Integer(2)], False), Integer(0), N=Integer(30))
1.7315451844777407992085512000
>>> f.green_function(P.point([Integer(2),Integer(1)], False), Integer(0), N=Integer(30))
0.86577259223181088325226209926
>>> f.green_function(P.point([Integer(1),Integer(1)], False), Integer(0), N=Integer(30))
0.43288629610862338612700146098

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.green_function(P.point([5,2], False), 0, N=30)
f.green_function(P.point([2,1], False), 0, N=30)
f.green_function(P.point([1,1], False), 0, N=30)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.green_function(P.point([Integer(5),Integer(2)], False), Integer(0), N=Integer(30))
1.7315451844777407992085512000
>>> f.green_function(P.point([Integer(2),Integer(1)], False), Integer(0), N=Integer(30))
0.86577259223181088325226209926
>>> f.green_function(P.point([Integer(1),Integer(1)], False), Integer(0), N=Integer(30))
0.43288629610862338612700146098

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.green_function(P.point([5,2], False), 0, N=30)
f.green_function(P.point([2,1], False), 0, N=30)
f.green_function(P.point([1,1], False), 0, N=30)
height_difference_bound(prec=None)[source]

Return an upper bound on the different between the canonical height of a point with respect to this dynamical system and the absolute height of the point.

This map must be a morphism.

ALGORITHM:

Uses a Nullstellensatz argument to compute the constant. For details: see [Hutz2015].

INPUT:

  • prec – (default: RealField default) positive integer, float point precision

OUTPUT: a real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: f.height_difference_bound()                                           # needs sage.symbolic
1.38629436111989

sage: P.<x,y,z> = ProjectiveSpace(ZZ, 2)
sage: f = DynamicalSystem_projective([4*x^2 + 100*y^2, 210*x*y, 10000*z^2])
sage: f.height_difference_bound()                                           # needs sage.symbolic
10.3089526606443

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.height_difference_bound()                                           # needs sage.symbolic
1.38629436111989

>>> P = ProjectiveSpace(ZZ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(4)*x**Integer(2) + Integer(100)*y**Integer(2), Integer(210)*x*y, Integer(10000)*z**Integer(2)])
>>> f.height_difference_bound()                                           # needs sage.symbolic
10.3089526606443

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.height_difference_bound()                                           # needs sage.symbolic
P.<x,y,z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem_projective([4*x^2 + 100*y^2, 210*x*y, 10000*z^2])
f.height_difference_bound()                                           # needs sage.symbolic

A number field example:

sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<c> = NumberField(x^3 - 2)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: f = DynamicalSystem_projective([1/(c+1)*x^2 + c*y^2, 210*x*y, 10000*z^2])
sage: f.height_difference_bound()                                           # needs sage.symbolic
11.3683039374269

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(3) - Integer(2), names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(1)/(c+Integer(1))*x**Integer(2) + c*y**Integer(2), Integer(210)*x*y, Integer(10000)*z**Integer(2)])
>>> f.height_difference_bound()                                           # needs sage.symbolic
11.3683039374269

# needs sage.rings.number_field
R.<x> = QQ[]
K.<c> = NumberField(x^3 - 2)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([1/(c+1)*x^2 + c*y^2, 210*x*y, 10000*z^2])
f.height_difference_bound()                                           # needs sage.symbolic
sage: # needs sage.rings.number_field sage.symbolic
sage: P.<x,y,z> = ProjectiveSpace(QQbar, 2)
sage: f = DynamicalSystem_projective([x^2, QQbar(sqrt(-1))*y^2,
....:                                 QQbar(sqrt(3))*z^2])
sage: f.height_difference_bound()
2.89037175789616

>>> from sage.all import *
>>> # needs sage.rings.number_field sage.symbolic
>>> P = ProjectiveSpace(QQbar, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), QQbar(sqrt(-Integer(1)))*y**Integer(2),
...                                 QQbar(sqrt(Integer(3)))*z**Integer(2)])
>>> f.height_difference_bound()
2.89037175789616

# needs sage.rings.number_field sage.symbolic
P.<x,y,z> = ProjectiveSpace(QQbar, 2)
f = DynamicalSystem_projective([x^2, QQbar(sqrt(-1))*y^2,
                                QQbar(sqrt(3))*z^2])
f.height_difference_bound()
>>> from sage.all import *
>>> # needs sage.rings.number_field sage.symbolic
>>> P = ProjectiveSpace(QQbar, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), QQbar(sqrt(-Integer(1)))*y**Integer(2),
...                                 QQbar(sqrt(Integer(3)))*z**Integer(2)])
>>> f.height_difference_bound()
2.89037175789616

# needs sage.rings.number_field sage.symbolic
P.<x,y,z> = ProjectiveSpace(QQbar, 2)
f = DynamicalSystem_projective([x^2, QQbar(sqrt(-1))*y^2,
                                QQbar(sqrt(3))*z^2])
f.height_difference_bound()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([5*x^2 + 3*x*y , y^2 + 3*x^2])
sage: f.height_difference_bound(prec=100)                                   # needs sage.symbolic
5.3375380797013179737224159274

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(5)*x**Integer(2) + Integer(3)*x*y , y**Integer(2) + Integer(3)*x**Integer(2)])
>>> f.height_difference_bound(prec=Integer(100))                                   # needs sage.symbolic
5.3375380797013179737224159274

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([5*x^2 + 3*x*y , y^2 + 3*x^2])
f.height_difference_bound(prec=100)                                   # needs sage.symbolic
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(5)*x**Integer(2) + Integer(3)*x*y , y**Integer(2) + Integer(3)*x**Integer(2)])
>>> f.height_difference_bound(prec=Integer(100))                                   # needs sage.symbolic
5.3375380797013179737224159274

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([5*x^2 + 3*x*y , y^2 + 3*x^2])
f.height_difference_bound(prec=100)                                   # needs sage.symbolic
is_Lattes()[source]

Check if self is a Lattes map.

OUTPUT: True if self is Lattes, False otherwise

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^3, y^3])
sage: F.is_Lattes()
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> F.is_Lattes()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, y^3])
F.is_Lattes()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: F.is_Lattes()
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> F.is_Lattes()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
F.is_Lattes()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> F.is_Lattes()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
F.is_Lattes()
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: F = DynamicalSystem_projective([x^2 + y^2 + z^2, y^2, z^2])
sage: F.is_Lattes()
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2) + z**Integer(2), y**Integer(2), z**Integer(2)])
>>> F.is_Lattes()
False

P.<x,y,z> = ProjectiveSpace(QQ, 2)
F = DynamicalSystem_projective([x^2 + y^2 + z^2, y^2, z^2])
F.is_Lattes()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2) + z**Integer(2), y**Integer(2), z**Integer(2)])
>>> F.is_Lattes()
False

P.<x,y,z> = ProjectiveSpace(QQ, 2)
F = DynamicalSystem_projective([x^2 + y^2 + z^2, y^2, z^2])
F.is_Lattes()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([(x + y)*(x - y)^3, y*(2*x + y)^3])
sage: F.is_Lattes()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)*(x - y)**Integer(3), y*(Integer(2)*x + y)**Integer(3)])
>>> F.is_Lattes()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)*(x - y)^3, y*(2*x + y)^3])
F.is_Lattes()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)*(x - y)**Integer(3), y*(Integer(2)*x + y)**Integer(3)])
>>> F.is_Lattes()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)*(x - y)^3, y*(2*x + y)^3])
F.is_Lattes()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([(x + y)^4, 16*x*y*(x - y)^2])
sage: F.is_Lattes()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)**Integer(4), Integer(16)*x*y*(x - y)**Integer(2)])
>>> F.is_Lattes()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)^4, 16*x*y*(x - y)^2])
F.is_Lattes()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)**Integer(4), Integer(16)*x*y*(x - y)**Integer(2)])
>>> F.is_Lattes()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)^4, 16*x*y*(x - y)^2])
F.is_Lattes()
sage: f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]),2)
sage: f.is_Lattes()
True

>>> from sage.all import *
>>> f = P.Lattes_map(EllipticCurve([Integer(0), Integer(0), Integer(0), Integer(0), Integer(2)]),Integer(2))
>>> f.is_Lattes()
True

f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]),2)
f.is_Lattes()
>>> from sage.all import *
>>> f = P.Lattes_map(EllipticCurve([Integer(0), Integer(0), Integer(0), Integer(0), Integer(2)]),Integer(2))
>>> f.is_Lattes()
True

f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]),2)
f.is_Lattes()
sage: f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]), 2)
sage: L.<i> = CyclotomicField(4)
sage: M = Matrix([[i, 0], [0, -i]])
sage: f.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-1/4*i)*x^4 + (-4*i)*x*y^3 : (-i)*x^3*y + (2*i)*y^4)
sage: f.is_Lattes()
True

>>> from sage.all import *
>>> f = P.Lattes_map(EllipticCurve([Integer(0), Integer(0), Integer(0), Integer(0), Integer(2)]), Integer(2))
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[i, Integer(0)], [Integer(0), -i]])
>>> f.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-1/4*i)*x^4 + (-4*i)*x*y^3 : (-i)*x^3*y + (2*i)*y^4)
>>> f.is_Lattes()
True

f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]), 2)
L.<i> = CyclotomicField(4)
M = Matrix([[i, 0], [0, -i]])
f.conjugate(M)
f.is_Lattes()
>>> from sage.all import *
>>> f = P.Lattes_map(EllipticCurve([Integer(0), Integer(0), Integer(0), Integer(0), Integer(2)]), Integer(2))
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[i, Integer(0)], [Integer(0), -i]])
>>> f.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-1/4*i)*x^4 + (-4*i)*x*y^3 : (-i)*x^3*y + (2*i)*y^4)
>>> f.is_Lattes()
True

f = P.Lattes_map(EllipticCurve([0, 0, 0, 0, 2]), 2)
L.<i> = CyclotomicField(4)
M = Matrix([[i, 0], [0, -i]])
f.conjugate(M)
f.is_Lattes()

REFERENCES:

is_PGL_minimal(prime_list=None)[source]

Check if this dynamical system is a minimal model in its conjugacy class.

See [BM2012] and [Mol2015] for a description of the algorithm. For polynomial maps it uses [HS2018].

INPUT:

  • prime_list – (optional) list of primes to check minimality

OUTPUT: boolean

EXAMPLES:

sage: PS.<X,Y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([X^2 + 3*Y^2, X*Y])
sage: f.is_PGL_minimal()                                                    # needs sage.rings.function_field
True

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([X**Integer(2) + Integer(3)*Y**Integer(2), X*Y])
>>> f.is_PGL_minimal()                                                    # needs sage.rings.function_field
True

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([X^2 + 3*Y^2, X*Y])
f.is_PGL_minimal()                                                    # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
sage: f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y])
>>> f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
f.is_PGL_minimal()                                                    # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y])
>>> f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
f.is_PGL_minimal()                                                    # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, y^2])
sage: f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), y**Integer(2)])
>>> f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, y^2])
f.is_PGL_minimal()                                                    # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), y**Integer(2)])
>>> f.is_PGL_minimal()                                                    # needs sage.rings.function_field
False

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, y^2])
f.is_PGL_minimal()                                                    # needs sage.rings.function_field
is_chebyshev()[source]

Check if self is a Chebyshev polynomial.

OUTPUT: True if self is Chebyshev, False otherwise

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^4, y^4])
sage: F.is_chebyshev()
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.is_chebyshev()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.is_chebyshev()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: F.is_chebyshev()
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> F.is_chebyshev()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^2 + y^2, y^2])
F.is_chebyshev()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> F.is_chebyshev()
False

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^2 + y^2, y^2])
F.is_chebyshev()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
sage: F.is_chebyshev()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
F.is_chebyshev()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
F.is_chebyshev()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^3, 4*y^3 - 3*x^2*y])
sage: F.is_chebyshev()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), Integer(4)*y**Integer(3) - Integer(3)*x**Integer(2)*y])
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, 4*y^3 - 3*x^2*y])
F.is_chebyshev()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), Integer(4)*y**Integer(3) - Integer(3)*x**Integer(2)*y])
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, 4*y^3 - 3*x^2*y])
F.is_chebyshev()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
sage: L.<i> = CyclotomicField(4)
sage: M = Matrix([[0,i],[-i,0]])
sage: F.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-i)*x^2 : (-i)*x^2 + (2*i)*y^2)
sage: F.is_chebyshev()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[Integer(0),i],[-i,Integer(0)]])
>>> F.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-i)*x^2 : (-i)*x^2 + (2*i)*y^2)
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
L.<i> = CyclotomicField(4)
M = Matrix([[0,i],[-i,0]])
F.conjugate(M)
F.is_chebyshev()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([Integer(2)*x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> L = CyclotomicField(Integer(4), names=('i',)); (i,) = L._first_ngens(1)
>>> M = Matrix([[Integer(0),i],[-i,Integer(0)]])
>>> F.conjugate(M)
Dynamical System of Projective Space of dimension 1 over
 Cyclotomic Field of order 4 and degree 2
  Defn: Defined on coordinates by sending (x : y) to
        ((-i)*x^2 : (-i)*x^2 + (2*i)*y^2)
>>> F.is_chebyshev()
True

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([2*x^2 - y^2, y^2])
L.<i> = CyclotomicField(4)
M = Matrix([[0,i],[-i,0]])
F.conjugate(M)
F.is_chebyshev()

REFERENCES:

is_dynamical_belyi_map()[source]

Return if this dynamical system is a dynamical Belyi map.

We define a dynamical Belyi map to be a map conjugate to a dynamical system \(f: \mathbb{P}^1 \to \mathbb{P}^1\) where the branch points are contained in \(\{0, 1, \infty \}\) and the postcritical set is contained in \(\{0, 1, \infty \}\).

Output: Boolean

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([-2*x^3 - 9*x^2*y - 12*x*y^2 - 6*y^3, y^3])
sage: f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(2)*x**Integer(3) - Integer(9)*x**Integer(2)*y - Integer(12)*x*y**Integer(2) - Integer(6)*y**Integer(3), y**Integer(3)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([-2*x^3 - 9*x^2*y - 12*x*y^2 - 6*y^3, y^3])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
sage: f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(7) - Integer(7)*x**Integer(6)*y, -Integer(7)*x*y**Integer(6) + Integer(5)*y**Integer(7)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(7) - Integer(7)*x**Integer(6)*y, -Integer(7)*x*y**Integer(6) + Integer(5)*y**Integer(7)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: F = QuadraticField(-7)
sage: P.<x,y> = ProjectiveSpace(F, 1)
sage: f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
sage: f.is_dynamical_belyi_map()
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> F = QuadraticField(-Integer(7))
>>> P = ProjectiveSpace(F, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(7) - Integer(7)*x**Integer(6)*y, -Integer(7)*x*y**Integer(6) + Integer(5)*y**Integer(7)])
>>> f.is_dynamical_belyi_map()
True

# needs sage.rings.number_field
F = QuadraticField(-7)
P.<x,y> = ProjectiveSpace(F, 1)
f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
f.is_dynamical_belyi_map()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> F = QuadraticField(-Integer(7))
>>> P = ProjectiveSpace(F, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(7) - Integer(7)*x**Integer(6)*y, -Integer(7)*x*y**Integer(6) + Integer(5)*y**Integer(7)])
>>> f.is_dynamical_belyi_map()
True

# needs sage.rings.number_field
F = QuadraticField(-7)
P.<x,y> = ProjectiveSpace(F, 1)
f = DynamicalSystem_projective([5*x^7 - 7*x^6*y, -7*x*y^6 + 5*y^7])
f.is_dynamical_belyi_map()
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([2*x^3 + 3*x^2*y - 3*x*y^2 + 2*y^3,
....:                                 x^3 + y^3])
sage: f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) + Integer(3)*x**Integer(2)*y - Integer(3)*x*y**Integer(2) + Integer(2)*y**Integer(3),
...                                 x**Integer(3) + y**Integer(3)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([2*x^3 + 3*x^2*y - 3*x*y^2 + 2*y^3,
                                x^3 + y^3])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) + Integer(3)*x**Integer(2)*y - Integer(3)*x*y**Integer(2) + Integer(2)*y**Integer(3),
...                                 x**Integer(3) + y**Integer(3)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([2*x^3 + 3*x^2*y - 3*x*y^2 + 2*y^3,
                                x^3 + y^3])
f.is_dynamical_belyi_map()                                            # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: R.<t> = PolynomialRing(QQ)
sage: N.<c> = NumberField(t^3 - 2)
sage: P.<x,y> = ProjectiveSpace(N, 1)
sage: f=DynamicalSystem_projective([x^2 + c*y^2, x*y])
sage: f.is_dynamical_belyi_map()
False

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> N = NumberField(t**Integer(3) - Integer(2), names=('c',)); (c,) = N._first_ngens(1)
>>> P = ProjectiveSpace(N, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f=DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), x*y])
>>> f.is_dynamical_belyi_map()
False

# needs sage.rings.number_field
R.<t> = PolynomialRing(QQ)
N.<c> = NumberField(t^3 - 2)
P.<x,y> = ProjectiveSpace(N, 1)
f=DynamicalSystem_projective([x^2 + c*y^2, x*y])
f.is_dynamical_belyi_map()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> N = NumberField(t**Integer(3) - Integer(2), names=('c',)); (c,) = N._first_ngens(1)
>>> P = ProjectiveSpace(N, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f=DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), x*y])
>>> f.is_dynamical_belyi_map()
False

# needs sage.rings.number_field
R.<t> = PolynomialRing(QQ)
N.<c> = NumberField(t^3 - 2)
P.<x,y> = ProjectiveSpace(N, 1)
f=DynamicalSystem_projective([x^2 + c*y^2, x*y])
f.is_dynamical_belyi_map()
sage: P.<x,y> = ProjectiveSpace(GF(7), 1)
sage: f = DynamicalSystem_projective([x^3 + 6*y^3, y^3])
sage: f.is_dynamical_belyi_map()                                            # needs sage.libs.pari
False

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(6)*y**Integer(3), y**Integer(3)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.libs.pari
False

P.<x,y> = ProjectiveSpace(GF(7), 1)
f = DynamicalSystem_projective([x^3 + 6*y^3, y^3])
f.is_dynamical_belyi_map()                                            # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(6)*y**Integer(3), y**Integer(3)])
>>> f.is_dynamical_belyi_map()                                            # needs sage.libs.pari
False

P.<x,y> = ProjectiveSpace(GF(7), 1)
f = DynamicalSystem_projective([x^3 + 6*y^3, y^3])
f.is_dynamical_belyi_map()                                            # needs sage.libs.pari
is_postcritically_finite(err=0.01, use_algebraic_closure=True)[source]

Determine if this dynamical system is post-critically finite.

Only for endomorphisms of \(\mathbb{P}^1\). It checks if each critical point is preperiodic. The optional parameter err is passed into is_preperiodic() as part of the preperiodic check.

The computations can be done either over the algebraic closure of the base field or over the minimal extension of the base field that contains the critical points.

INPUT:

  • err – (default: 0.01) positive real number

  • use_algebraic_closure – boolean (default: True); if True, uses the algebraic closure. If False, uses the smallest extension of the base field containing all the critical points.

OUTPUT: boolean

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.is_postcritically_finite()                                          # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.is_postcritically_finite()                                          # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.is_postcritically_finite()                                          # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3 - y^3, y^3])
sage: f.is_postcritically_finite()                                          # needs sage.rings.number_field
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - y**Integer(3), y**Integer(3)])
>>> f.is_postcritically_finite()                                          # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - y^3, y^3])
f.is_postcritically_finite()                                          # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - y**Integer(3), y**Integer(3)])
>>> f.is_postcritically_finite()                                          # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3 - y^3, y^3])
f.is_postcritically_finite()                                          # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: K.<v> = NumberField(z^8 + 3*z^6 + 3*z^4 + z^2 + 1)
sage: PS.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^3 + v*y^3, y^3])
sage: f.is_postcritically_finite()  # long time
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(8) + Integer(3)*z**Integer(6) + Integer(3)*z**Integer(4) + z**Integer(2) + Integer(1), names=('v',)); (v,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + v*y**Integer(3), y**Integer(3)])
>>> f.is_postcritically_finite()  # long time
True

# needs sage.rings.number_field
R.<z> = QQ[]
K.<v> = NumberField(z^8 + 3*z^6 + 3*z^4 + z^2 + 1)
PS.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 + v*y^3, y^3])
f.is_postcritically_finite()  # long time
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(8) + Integer(3)*z**Integer(6) + Integer(3)*z**Integer(4) + z**Integer(2) + Integer(1), names=('v',)); (v,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + v*y**Integer(3), y**Integer(3)])
>>> f.is_postcritically_finite()  # long time
True

# needs sage.rings.number_field
R.<z> = QQ[]
K.<v> = NumberField(z^8 + 3*z^6 + 3*z^4 + z^2 + 1)
PS.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 + v*y^3, y^3])
f.is_postcritically_finite()  # long time
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([6*x^2 + 16*x*y + 16*y^2,
....:                                 -3*x^2 - 4*x*y - 4*y^2])
sage: f.is_postcritically_finite()                                          # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(16)*x*y + Integer(16)*y**Integer(2),
...                                 -Integer(3)*x**Integer(2) - Integer(4)*x*y - Integer(4)*y**Integer(2)])
>>> f.is_postcritically_finite()                                          # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 16*x*y + 16*y^2,
                                -3*x^2 - 4*x*y - 4*y^2])
f.is_postcritically_finite()                                          # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(16)*x*y + Integer(16)*y**Integer(2),
...                                 -Integer(3)*x**Integer(2) - Integer(4)*x*y - Integer(4)*y**Integer(2)])
>>> f.is_postcritically_finite()                                          # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 16*x*y + 16*y^2,
                                -3*x^2 - 4*x*y - 4*y^2])
f.is_postcritically_finite()                                          # needs sage.rings.number_field
sage: # needs sage.libs.gap sage.rings.number_field
sage: K = UniversalCyclotomicField()
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: F = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
sage: F.is_postcritically_finite()
True

>>> from sage.all import *
>>> # needs sage.libs.gap sage.rings.number_field
>>> K = UniversalCyclotomicField()
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> F.is_postcritically_finite()
True

# needs sage.libs.gap sage.rings.number_field
K = UniversalCyclotomicField()
P.<x,y> = ProjectiveSpace(K,1)
F = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
F.is_postcritically_finite()
>>> from sage.all import *
>>> # needs sage.libs.gap sage.rings.number_field
>>> K = UniversalCyclotomicField()
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> F.is_postcritically_finite()
True

# needs sage.libs.gap sage.rings.number_field
K = UniversalCyclotomicField()
P.<x,y> = ProjectiveSpace(K,1)
F = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
F.is_postcritically_finite()
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
sage: f.is_postcritically_finite(use_algebraic_closure=False)  # long time
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)  # long time
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)  # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(8)*x**Integer(4) - Integer(8)*x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)  # long time
True

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([8*x^4 - 8*x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)  # long time
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
sage: f.is_postcritically_finite(use_algebraic_closure=False)               # needs sage.rings.number_field
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)               # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)               # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)               # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)               # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar,1)
sage: f = DynamicalSystem_projective([x^4 - x^2*y^2, y^4])
sage: f.is_postcritically_finite()
False

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2), y**Integer(4)])
>>> f.is_postcritically_finite()
False

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar,1)
f = DynamicalSystem_projective([x^4 - x^2*y^2, y^4])
f.is_postcritically_finite()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2), y**Integer(4)])
>>> f.is_postcritically_finite()
False

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar,1)
f = DynamicalSystem_projective([x^4 - x^2*y^2, y^4])
f.is_postcritically_finite()
minimal_model(return_transformation=False, prime_list=None, algorithm=None, check_primes=True)[source]

Determine if this dynamical system is minimal.

This dynamical system must be defined over the projective line over the rationals. In particular, determine if this map is affine minimal, which is enough to decide if it is minimal or not. See Proposition 2.10 in [BM2012].

INPUT:

  • return_transformation – boolean (default: False); this signals a return of the \(PGL_2\) transformation to conjugate this map to the calculated minimal model

  • prime_list – (optional) a list of primes, in case one only wants to determine minimality at those specific primes

  • algorithm – (optional) string; can be one of the following:

  • check_primes – (optional) boolean; this signals whether to

    check whether each element in prime_list is a prime

    • 'BM' – the Bruin-Molnar algorithm [BM2012]

    • 'HS' – the Hutz-Stoll algorithm [HS2018]

OUTPUT:

  • a dynamical system on the projective line which is a minimal model of this map

  • a \(PGL(2,\QQ)\) element which conjugates this map to a minimal model

EXAMPLES:

sage: PS.<X,Y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([X^2 + 3*Y^2, X*Y])
sage: f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational
Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 + 3*Y^2 : X*Y)
,
[1 0]
[0 1]
)

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([X**Integer(2) + Integer(3)*Y**Integer(2), X*Y])
>>> f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational
Field
  Defn: Defined on coordinates by sending (X : Y) to
        (X^2 + 3*Y^2 : X*Y)
,
[1 0]
[0 1]
)

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([X^2 + 3*Y^2, X*Y])
f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
sage: PS.<X,Y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([7365/2*X^4 + 6282*X^3*Y + 4023*X^2*Y^2
....:                                   + 1146*X*Y^3 + 245/2*Y^4,
....:                                 -12329/2*X^4 - 10506*X^3*Y - 6723*X^2*Y^2
....:                                   - 1914*X*Y^3 - 409/2*Y^4])
sage: f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (9847*X^4 + 28088*X^3*Y + 30048*X^2*Y^2 + 14288*X*Y^3 + 2548*Y^4
        : -12329*X^4 - 35164*X^3*Y - 37614*X^2*Y^2 - 17884*X*Y^3 - 3189*Y^4),

[2 1]
[0 1]
)

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7365)/Integer(2)*X**Integer(4) + Integer(6282)*X**Integer(3)*Y + Integer(4023)*X**Integer(2)*Y**Integer(2)
...                                   + Integer(1146)*X*Y**Integer(3) + Integer(245)/Integer(2)*Y**Integer(4),
...                                 -Integer(12329)/Integer(2)*X**Integer(4) - Integer(10506)*X**Integer(3)*Y - Integer(6723)*X**Integer(2)*Y**Integer(2)
...                                   - Integer(1914)*X*Y**Integer(3) - Integer(409)/Integer(2)*Y**Integer(4)])
>>> f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (9847*X^4 + 28088*X^3*Y + 30048*X^2*Y^2 + 14288*X*Y^3 + 2548*Y^4
        : -12329*X^4 - 35164*X^3*Y - 37614*X^2*Y^2 - 17884*X*Y^3 - 3189*Y^4),
<BLANKLINE>
[2 1]
[0 1]
)

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7365/2*X^4 + 6282*X^3*Y + 4023*X^2*Y^2
                                  + 1146*X*Y^3 + 245/2*Y^4,
                                -12329/2*X^4 - 10506*X^3*Y - 6723*X^2*Y^2
                                  - 1914*X*Y^3 - 409/2*Y^4])
f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7365)/Integer(2)*X**Integer(4) + Integer(6282)*X**Integer(3)*Y + Integer(4023)*X**Integer(2)*Y**Integer(2)
...                                   + Integer(1146)*X*Y**Integer(3) + Integer(245)/Integer(2)*Y**Integer(4),
...                                 -Integer(12329)/Integer(2)*X**Integer(4) - Integer(10506)*X**Integer(3)*Y - Integer(6723)*X**Integer(2)*Y**Integer(2)
...                                   - Integer(1914)*X*Y**Integer(3) - Integer(409)/Integer(2)*Y**Integer(4)])
>>> f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (9847*X^4 + 28088*X^3*Y + 30048*X^2*Y^2 + 14288*X*Y^3 + 2548*Y^4
        : -12329*X^4 - 35164*X^3*Y - 37614*X^2*Y^2 - 17884*X*Y^3 - 3189*Y^4),
<BLANKLINE>
[2 1]
[0 1]
)

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7365/2*X^4 + 6282*X^3*Y + 4023*X^2*Y^2
                                  + 1146*X*Y^3 + 245/2*Y^4,
                                -12329/2*X^4 - 10506*X^3*Y - 6723*X^2*Y^2
                                  - 1914*X*Y^3 - 409/2*Y^4])
f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
sage: f.minimal_model()                                                     # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + 12*x*y + 42*y^2 : 2*x*y)

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y])
>>> f.minimal_model()                                                     # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + 12*x*y + 42*y^2 : 2*x*y)

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
f.minimal_model()                                                     # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y])
>>> f.minimal_model()                                                     # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 + 12*x*y + 42*y^2 : 2*x*y)

PS.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y])
f.minimal_model()                                                     # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
sage: g,M = f.minimal_model(return_transformation=True, algorithm='BM')     # needs sage.rings.function_field
sage: f.conjugate(M) == g                                                   # needs sage.rings.function_field
True

>>> from sage.all import *
>>> PS = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y + Integer(42)*y**Integer(2)])
>>> g,M = f.minimal_model(return_transformation=True, algorithm='BM')     # needs sage.rings.function_field
>>> f.conjugate(M) == g                                                   # needs sage.rings.function_field
True

PS.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
g,M = f.minimal_model(return_transformation=True, algorithm='BM')     # needs sage.rings.function_field
f.conjugate(M) == g                                                   # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y + Integer(42)*y**Integer(2)])
>>> g,M = f.minimal_model(return_transformation=True, algorithm='BM')     # needs sage.rings.function_field
>>> f.conjugate(M) == g                                                   # needs sage.rings.function_field
True

PS.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
g,M = f.minimal_model(return_transformation=True, algorithm='BM')     # needs sage.rings.function_field
f.conjugate(M) == g                                                   # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([2*x^2, y^2])
sage: f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 : y^2)                                                    ,
[1 0]
[0 2]
)
sage: f.minimal_model(prime_list=[3])                                       # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 : y^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(2)*x**Integer(2), y**Integer(2)])
>>> f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 : y^2)                                                    ,
[1 0]
[0 2]
)
>>> f.minimal_model(prime_list=[Integer(3)])                                       # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 : y^2)

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([2*x^2, y^2])
f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
f.minimal_model(prime_list=[3])                                       # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(2)*x**Integer(2), y**Integer(2)])
>>> f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 : y^2)                                                    ,
[1 0]
[0 2]
)
>>> f.minimal_model(prime_list=[Integer(3)])                                       # needs sage.rings.function_field
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 : y^2)

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([2*x^2, y^2])
f.minimal_model(return_transformation=True)                           # needs sage.rings.function_field
f.minimal_model(prime_list=[3])                                       # needs sage.rings.function_field

REFERENCES:

multiplier(P, n, check=True)[source]

Return the multiplier of the point P of period n with respect to this dynamical system.

INPUT:

  • P – a point on domain of this map

  • n – positive integer, the period of P

  • check – boolean (default: True); verify that P has period n

OUTPUT:

A square matrix of size self.codomain().dimension_relative() in the base_ring of this dynamical system.

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([x^2, y^2, 4*z^2])
sage: Q = P.point([4,4,1], False)
sage: f.multiplier(Q,1)
[2 0]
[0 2]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), Integer(4)*z**Integer(2)])
>>> Q = P.point([Integer(4),Integer(4),Integer(1)], False)
>>> f.multiplier(Q,Integer(1))
[2 0]
[0 2]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2, y^2, 4*z^2])
Q = P.point([4,4,1], False)
f.multiplier(Q,1)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([7*x^2 - 28*y^2, 24*x*y])
sage: f.multiplier(P(2,5), 4)
[231361/20736]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x**Integer(2) - Integer(28)*y**Integer(2), Integer(24)*x*y])
>>> f.multiplier(P(Integer(2),Integer(5)), Integer(4))
[231361/20736]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7*x^2 - 28*y^2, 24*x*y])
f.multiplier(P(2,5), 4)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x**Integer(2) - Integer(28)*y**Integer(2), Integer(24)*x*y])
>>> f.multiplier(P(Integer(2),Integer(5)), Integer(4))
[231361/20736]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7*x^2 - 28*y^2, 24*x*y])
f.multiplier(P(2,5), 4)
sage: P.<x,y> = ProjectiveSpace(CC,1)
sage: f = DynamicalSystem_projective([x^3 - 25*x*y^2 + 12*y^3, 12*y^3])
sage: f.multiplier(P(1,1), 5)
[0.389017489711934]

>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(25)*x*y**Integer(2) + Integer(12)*y**Integer(3), Integer(12)*y**Integer(3)])
>>> f.multiplier(P(Integer(1),Integer(1)), Integer(5))
[0.389017489711934]

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^3 - 25*x*y^2 + 12*y^3, 12*y^3])
f.multiplier(P(1,1), 5)
>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(25)*x*y**Integer(2) + Integer(12)*y**Integer(3), Integer(12)*y**Integer(3)])
>>> f.multiplier(P(Integer(1),Integer(1)), Integer(5))
[0.389017489711934]

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^3 - 25*x*y^2 + 12*y^3, 12*y^3])
f.multiplier(P(1,1), 5)
sage: P.<x,y> = ProjectiveSpace(RR,1)
sage: f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: f.multiplier(P(2,1), 1)
[4.00000000000000]

>>> from sage.all import *
>>> P = ProjectiveSpace(RR,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(2),Integer(1)), Integer(1))
[4.00000000000000]

P.<x,y> = ProjectiveSpace(RR,1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.multiplier(P(2,1), 1)
>>> from sage.all import *
>>> P = ProjectiveSpace(RR,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(2),Integer(1)), Integer(1))
[4.00000000000000]

P.<x,y> = ProjectiveSpace(RR,1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.multiplier(P(2,1), 1)
sage: P.<x,y> = ProjectiveSpace(Qp(13),1)                                   # needs sage.rings.padics
sage: f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
sage: f.multiplier(P(5,4), 3)                                               # needs sage.rings.padics
[6 + 8*13 + 13^2 + 8*13^3 + 13^4 + 8*13^5 + 13^6 + 8*13^7 + 13^8 +
 8*13^9 + 13^10 + 8*13^11 + 13^12 + 8*13^13 + 13^14 + 8*13^15 + 13^16 +
 8*13^17 + 13^18 + 8*13^19 + O(13^20)]

>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)# needs sage.rings.padics
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(5),Integer(4)), Integer(3))                                               # needs sage.rings.padics
[6 + 8*13 + 13^2 + 8*13^3 + 13^4 + 8*13^5 + 13^6 + 8*13^7 + 13^8 +
 8*13^9 + 13^10 + 8*13^11 + 13^12 + 8*13^13 + 13^14 + 8*13^15 + 13^16 +
 8*13^17 + 13^18 + 8*13^19 + O(13^20)]

P.<x,y> = ProjectiveSpace(Qp(13),1)                                   # needs sage.rings.padics
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.multiplier(P(5,4), 3)                                               # needs sage.rings.padics
>>> from sage.all import *
>>> P = ProjectiveSpace(Qp(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)# needs sage.rings.padics
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(5),Integer(4)), Integer(3))                                               # needs sage.rings.padics
[6 + 8*13 + 13^2 + 8*13^3 + 13^4 + 8*13^5 + 13^6 + 8*13^7 + 13^8 +
 8*13^9 + 13^10 + 8*13^11 + 13^12 + 8*13^13 + 13^14 + 8*13^15 + 13^16 +
 8*13^17 + 13^18 + 8*13^19 + O(13^20)]

P.<x,y> = ProjectiveSpace(Qp(13),1)                                   # needs sage.rings.padics
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.multiplier(P(5,4), 3)                                               # needs sage.rings.padics
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.multiplier(P(0,1), 1)
Traceback (most recent call last):
...
ValueError: (0 : 1) is not periodic of period 1

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(0),Integer(1)), Integer(1))
Traceback (most recent call last):
...
ValueError: (0 : 1) is not periodic of period 1

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.multiplier(P(0,1), 1)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.multiplier(P(Integer(0),Integer(1)), Integer(1))
Traceback (most recent call last):
...
ValueError: (0 : 1) is not periodic of period 1

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.multiplier(P(0,1), 1)
multiplier_spectra(n, formal=False, type='point', use_algebraic_closure=True, check=True)[source]

Compute the n multiplier spectra of this dynamical system.

This is the set of multipliers of all peroidic points of period n included with the appropriate multiplicity. User can also specify to compute the formal n multiplier spectra instead which includes the multipliers of all formal periodic points of period n with appropriate multiplicity. The map must be defined over projective space over a number field or finite field.

By default, the computations are done over the algebraic closure of the base field. If the map is defined over projective space of dimension 1, the computation can be done over the minimal extension of the base field that contains the periodic points. Otherwise, it will be done over the base ring of the map.

INPUT:

  • n – positive integer, the period

  • formal – boolean (default: False); True specifies to find the formal n multiplier spectra of this map and False specifies to find the n multiplier spectra

  • type – (default: 'point') string; either 'point' or 'cycle' depending on whether you compute one multiplier per point or one per cycle

  • use_algebraic_closure – boolean (default: True); if True uses the algebraic closure. Using the algebraic closure can sometimes lead to numerical instability and extraneous errors. For most accurate results in dimension 1, set to False. If False, and the map is defined over projective space of dimension 1, uses the smallest extension of the base field containing all the periodic points. If the map is defined over projective space of dimension greater than 1, then the base ring of the map is used.

  • check – boolean (default: True); whether to check if the full multiplier spectra was computed. If False, can lead to mathematically incorrect answers in dimension greater than 1. Ignored if use_algebraic_closure is True or if this dynamical system is defined over projective space of dimension 1.

OUTPUT:

A list of field elements if the domain of the map is projective space of dimension 1. If the domain of the map is projective space of dimension greater than 1, a list of matrices

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sage: sorted(f.multiplier_spectra(2, type='point'))                         # needs sage.rings.number_field
[0, 1, 1, 1, 9]
sage: sorted(f.multiplier_spectra(2, type='cycle'))                         # needs sage.rings.number_field
[0, 1, 1, 9]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.multiplier_spectra(Integer(2), type='point'))                         # needs sage.rings.number_field
[0, 1, 1, 1, 9]
>>> sorted(f.multiplier_spectra(Integer(2), type='cycle'))                         # needs sage.rings.number_field
[0, 1, 1, 9]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sorted(f.multiplier_spectra(2, type='point'))                         # needs sage.rings.number_field
sorted(f.multiplier_spectra(2, type='cycle'))                         # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, z^2, y^2])
sage: f.multiplier_spectra(1)                                               # needs sage.rings.number_field
[
[                       2 1 - 1.732050807568878?*I]
[                       0                       -2],
[                       2 1 + 1.732050807568878?*I]  [ 0  0]  [ 0  0]
[                       0                       -2], [ 0 -2], [ 0 -2],
[ 0  0]  [0 0]  [ 2 -2]
[ 0 -2], [0 0], [ 0 -2]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))                                               # needs sage.rings.number_field
[
[                       2 1 - 1.732050807568878?*I]
[                       0                       -2],
[                       2 1 + 1.732050807568878?*I]  [ 0  0]  [ 0  0]
[                       0                       -2], [ 0 -2], [ 0 -2],
[ 0  0]  [0 0]  [ 2 -2]
[ 0 -2], [0 0], [ 0 -2]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, z^2, y^2])
f.multiplier_spectra(1)                                               # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))                                               # needs sage.rings.number_field
[
[                       2 1 - 1.732050807568878?*I]
[                       0                       -2],
[                       2 1 + 1.732050807568878?*I]  [ 0  0]  [ 0  0]
[                       0                       -2], [ 0 -2], [ 0 -2],
[ 0  0]  [0 0]  [ 2 -2]
[ 0 -2], [0 0], [ 0 -2]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, z^2, y^2])
f.multiplier_spectra(1)                                               # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, z^2, y^2])
sage: f.multiplier_spectra(2, formal=True)  # long time
[
[4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [0 0]  [0 0]
[0 4], [0 0], [0 0], [0 4], [0 4], [0 0], [0 0], [0 4], [0 0], [0 0],
[4 0]  [4 0]  [4 0]  [4 0]
[0 4], [0 4], [0 0], [0 0]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(2), formal=True)  # long time
[
[4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [0 0]  [0 0]
[0 4], [0 0], [0 0], [0 4], [0 4], [0 0], [0 0], [0 4], [0 0], [0 0],
[4 0]  [4 0]  [4 0]  [4 0]
[0 4], [0 4], [0 0], [0 0]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, z^2, y^2])
f.multiplier_spectra(2, formal=True)  # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(2), formal=True)  # long time
[
[4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [4 0]  [0 0]  [0 0]
[0 4], [0 0], [0 0], [0 4], [0 4], [0 0], [0 0], [0 4], [0 0], [0 0],
[4 0]  [4 0]  [4 0]  [4 0]
[0 4], [0 4], [0 0], [0 0]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, z^2, y^2])
f.multiplier_spectra(2, formal=True)  # long time
sage: # needs sage.rings.number_field
sage: set_verbose(None)
sage: z = QQ['z'].0
sage: K.<w> = NumberField(z^4 - 4*z^2 + 1,'z')
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 - w/4*y^2, y^2])
sage: sorted(f.multiplier_spectra(2, formal=False, type='cycle'))
[0,
 0.0681483474218635? - 1.930649271699173?*I,
 0.0681483474218635? + 1.930649271699173?*I,
 5.931851652578137? + 0.?e-49*I]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> z = QQ['z'].gen(0)
>>> K = NumberField(z**Integer(4) - Integer(4)*z**Integer(2) + Integer(1),'z', names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - w/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.multiplier_spectra(Integer(2), formal=False, type='cycle'))
[0,
 0.0681483474218635? - 1.930649271699173?*I,
 0.0681483474218635? + 1.930649271699173?*I,
 5.931851652578137? + 0.?e-49*I]

# needs sage.rings.number_field
set_verbose(None)
z = QQ['z'].0
K.<w> = NumberField(z^4 - 4*z^2 + 1,'z')
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - w/4*y^2, y^2])
sorted(f.multiplier_spectra(2, formal=False, type='cycle'))
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> z = QQ['z'].gen(0)
>>> K = NumberField(z**Integer(4) - Integer(4)*z**Integer(2) + Integer(1),'z', names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - w/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.multiplier_spectra(Integer(2), formal=False, type='cycle'))
[0,
 0.0681483474218635? - 1.930649271699173?*I,
 0.0681483474218635? + 1.930649271699173?*I,
 5.931851652578137? + 0.?e-49*I]

# needs sage.rings.number_field
set_verbose(None)
z = QQ['z'].0
K.<w> = NumberField(z^4 - 4*z^2 + 1,'z')
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - w/4*y^2, y^2])
sorted(f.multiplier_spectra(2, formal=False, type='cycle'))
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([4608*x^10 - 2910096*x^9*y + 325988068*x^8*y^2
....:         + 31825198932*x^7*y^3 - 4139806626613*x^6*y^4 - 44439736715486*x^5*y^5
....:         + 2317935971590902*x^4*y^6 - 15344764859590852*x^3*y^7
....:         + 2561851642765275*x^2*y^8 + 113578270285012470*x*y^9
....:         - 150049940203963800*y^10, 4608*y^10])
sage: sorted(f.multiplier_spectra(1))                                       # needs sage.rings.number_field
[-119820502365680843999,
 -7198147681176255644585/256,
 -3086380435599991/9,
 -3323781962860268721722583135/35184372088832,
 -4290991994944936653/2097152,
 0,
 529278480109921/256,
 1061953534167447403/19683,
 848446157556848459363/19683,
 82911372672808161930567/8192,
 3553497751559301575157261317/8192]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(4608)*x**Integer(10) - Integer(2910096)*x**Integer(9)*y + Integer(325988068)*x**Integer(8)*y**Integer(2)
...         + Integer(31825198932)*x**Integer(7)*y**Integer(3) - Integer(4139806626613)*x**Integer(6)*y**Integer(4) - Integer(44439736715486)*x**Integer(5)*y**Integer(5)
...         + Integer(2317935971590902)*x**Integer(4)*y**Integer(6) - Integer(15344764859590852)*x**Integer(3)*y**Integer(7)
...         + Integer(2561851642765275)*x**Integer(2)*y**Integer(8) + Integer(113578270285012470)*x*y**Integer(9)
...         - Integer(150049940203963800)*y**Integer(10), Integer(4608)*y**Integer(10)])
>>> sorted(f.multiplier_spectra(Integer(1)))                                       # needs sage.rings.number_field
[-119820502365680843999,
 -7198147681176255644585/256,
 -3086380435599991/9,
 -3323781962860268721722583135/35184372088832,
 -4290991994944936653/2097152,
 0,
 529278480109921/256,
 1061953534167447403/19683,
 848446157556848459363/19683,
 82911372672808161930567/8192,
 3553497751559301575157261317/8192]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([4608*x^10 - 2910096*x^9*y + 325988068*x^8*y^2
        + 31825198932*x^7*y^3 - 4139806626613*x^6*y^4 - 44439736715486*x^5*y^5
        + 2317935971590902*x^4*y^6 - 15344764859590852*x^3*y^7
        + 2561851642765275*x^2*y^8 + 113578270285012470*x*y^9
        - 150049940203963800*y^10, 4608*y^10])
sorted(f.multiplier_spectra(1))                                       # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(4608)*x**Integer(10) - Integer(2910096)*x**Integer(9)*y + Integer(325988068)*x**Integer(8)*y**Integer(2)
...         + Integer(31825198932)*x**Integer(7)*y**Integer(3) - Integer(4139806626613)*x**Integer(6)*y**Integer(4) - Integer(44439736715486)*x**Integer(5)*y**Integer(5)
...         + Integer(2317935971590902)*x**Integer(4)*y**Integer(6) - Integer(15344764859590852)*x**Integer(3)*y**Integer(7)
...         + Integer(2561851642765275)*x**Integer(2)*y**Integer(8) + Integer(113578270285012470)*x*y**Integer(9)
...         - Integer(150049940203963800)*y**Integer(10), Integer(4608)*y**Integer(10)])
>>> sorted(f.multiplier_spectra(Integer(1)))                                       # needs sage.rings.number_field
[-119820502365680843999,
 -7198147681176255644585/256,
 -3086380435599991/9,
 -3323781962860268721722583135/35184372088832,
 -4290991994944936653/2097152,
 0,
 529278480109921/256,
 1061953534167447403/19683,
 848446157556848459363/19683,
 82911372672808161930567/8192,
 3553497751559301575157261317/8192]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([4608*x^10 - 2910096*x^9*y + 325988068*x^8*y^2
        + 31825198932*x^7*y^3 - 4139806626613*x^6*y^4 - 44439736715486*x^5*y^5
        + 2317935971590902*x^4*y^6 - 15344764859590852*x^3*y^7
        + 2561851642765275*x^2*y^8 + 113578270285012470*x*y^9
        - 150049940203963800*y^10, 4608*y^10])
sorted(f.multiplier_spectra(1))                                       # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 7/4*y^2, y^2])
sage: f.multiplier_spectra(3, formal=True, type='cycle')                    # needs sage.rings.number_field
[1, 1]
sage: f.multiplier_spectra(3, formal=True, type='point')                    # needs sage.rings.number_field
[1, 1, 1, 1, 1, 1]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(7)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(3), formal=True, type='cycle')                    # needs sage.rings.number_field
[1, 1]
>>> f.multiplier_spectra(Integer(3), formal=True, type='point')                    # needs sage.rings.number_field
[1, 1, 1, 1, 1, 1]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 7/4*y^2, y^2])
f.multiplier_spectra(3, formal=True, type='cycle')                    # needs sage.rings.number_field
f.multiplier_spectra(3, formal=True, type='point')                    # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(7)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.multiplier_spectra(Integer(3), formal=True, type='cycle')                    # needs sage.rings.number_field
[1, 1]
>>> f.multiplier_spectra(Integer(3), formal=True, type='point')                    # needs sage.rings.number_field
[1, 1, 1, 1, 1, 1]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 7/4*y^2, y^2])
f.multiplier_spectra(3, formal=True, type='cycle')                    # needs sage.rings.number_field
f.multiplier_spectra(3, formal=True, type='point')                    # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^4 + 3*y^4, 4*x^2*y^2])
sage: f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.number_field
[0,
 -1,
 1/128*a^5 - 13/384*a^4 + 5/96*a^3 + 1/16*a^2 + 43/128*a + 303/128,
 -1/288*a^5 + 1/96*a^4 + 1/24*a^3 - 1/3*a^2 + 5/32*a - 115/32,
 -5/1152*a^5 + 3/128*a^4 - 3/32*a^3 + 13/48*a^2 - 63/128*a - 227/128]
sage: f.multiplier_spectra(1)                                               # needs sage.rings.number_field
[0,
 -1,
 1.951373035591442?,
 -2.475686517795721? - 0.730035681602057?*I,
 -2.475686517795721? + 0.730035681602057?*I]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) + Integer(3)*y**Integer(4), Integer(4)*x**Integer(2)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1), use_algebraic_closure=False)                  # needs sage.rings.number_field
[0,
 -1,
 1/128*a^5 - 13/384*a^4 + 5/96*a^3 + 1/16*a^2 + 43/128*a + 303/128,
 -1/288*a^5 + 1/96*a^4 + 1/24*a^3 - 1/3*a^2 + 5/32*a - 115/32,
 -5/1152*a^5 + 3/128*a^4 - 3/32*a^3 + 13/48*a^2 - 63/128*a - 227/128]
>>> f.multiplier_spectra(Integer(1))                                               # needs sage.rings.number_field
[0,
 -1,
 1.951373035591442?,
 -2.475686517795721? - 0.730035681602057?*I,
 -2.475686517795721? + 0.730035681602057?*I]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^4 + 3*y^4, 4*x^2*y^2])
f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.number_field
f.multiplier_spectra(1)                                               # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) + Integer(3)*y**Integer(4), Integer(4)*x**Integer(2)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1), use_algebraic_closure=False)                  # needs sage.rings.number_field
[0,
 -1,
 1/128*a^5 - 13/384*a^4 + 5/96*a^3 + 1/16*a^2 + 43/128*a + 303/128,
 -1/288*a^5 + 1/96*a^4 + 1/24*a^3 - 1/3*a^2 + 5/32*a - 115/32,
 -5/1152*a^5 + 3/128*a^4 - 3/32*a^3 + 13/48*a^2 - 63/128*a - 227/128]
>>> f.multiplier_spectra(Integer(1))                                               # needs sage.rings.number_field
[0,
 -1,
 1.951373035591442?,
 -2.475686517795721? - 0.730035681602057?*I,
 -2.475686517795721? + 0.730035681602057?*I]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^4 + 3*y^4, 4*x^2*y^2])
f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.number_field
f.multiplier_spectra(1)                                               # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(GF(5), 1)
sage: f = DynamicalSystem_projective([x^4 + 2*y^4, 4*x^2*y^2])
sage: f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.finite_rings
[0, 3*a + 3, 2*a + 1, 1, 1]
sage: f.multiplier_spectra(1)
[0, 2*z2 + 1, 3*z2 + 3, 1, 1]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) + Integer(2)*y**Integer(4), Integer(4)*x**Integer(2)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1), use_algebraic_closure=False)                  # needs sage.rings.finite_rings
[0, 3*a + 3, 2*a + 1, 1, 1]
>>> f.multiplier_spectra(Integer(1))
[0, 2*z2 + 1, 3*z2 + 3, 1, 1]

P.<x,y> = ProjectiveSpace(GF(5), 1)
f = DynamicalSystem_projective([x^4 + 2*y^4, 4*x^2*y^2])
f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.finite_rings
f.multiplier_spectra(1)
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) + Integer(2)*y**Integer(4), Integer(4)*x**Integer(2)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1), use_algebraic_closure=False)                  # needs sage.rings.finite_rings
[0, 3*a + 3, 2*a + 1, 1, 1]
>>> f.multiplier_spectra(Integer(1))
[0, 2*z2 + 1, 3*z2 + 3, 1, 1]

P.<x,y> = ProjectiveSpace(GF(5), 1)
f = DynamicalSystem_projective([x^4 + 2*y^4, 4*x^2*y^2])
f.multiplier_spectra(1, use_algebraic_closure=False)                  # needs sage.rings.finite_rings
f.multiplier_spectra(1)
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([x^5 + 3*y^5, 4*x^3*y^2])
sage: f.multiplier_spectra(1)
[0,
 -4.106544657178796?,
 -7/4,
 1.985176555073911?,
 -3.064315948947558? - 1.150478041113253?*I,
 -3.064315948947558? + 1.150478041113253?*I]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(3)*y**Integer(5), Integer(4)*x**Integer(3)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))
[0,
 -4.106544657178796?,
 -7/4,
 1.985176555073911?,
 -3.064315948947558? - 1.150478041113253?*I,
 -3.064315948947558? + 1.150478041113253?*I]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^5 + 3*y^5, 4*x^3*y^2])
f.multiplier_spectra(1)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(3)*y**Integer(5), Integer(4)*x**Integer(3)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))
[0,
 -4.106544657178796?,
 -7/4,
 1.985176555073911?,
 -3.064315948947558? - 1.150478041113253?*I,
 -3.064315948947558? + 1.150478041113253?*I]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^5 + 3*y^5, 4*x^3*y^2])
f.multiplier_spectra(1)
sage: K = GF(3).algebraic_closure()
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^5 + 2*y^5, 4*x^3*y^2])
sage: f.multiplier_spectra(1)
[0, z3 + 2, z3 + 1, z3, 1, 1]

>>> from sage.all import *
>>> K = GF(Integer(3)).algebraic_closure()
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(2)*y**Integer(5), Integer(4)*x**Integer(3)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))
[0, z3 + 2, z3 + 1, z3, 1, 1]

K = GF(3).algebraic_closure()
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^5 + 2*y^5, 4*x^3*y^2])
f.multiplier_spectra(1)
>>> from sage.all import *
>>> K = GF(Integer(3)).algebraic_closure()
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5) + Integer(2)*y**Integer(5), Integer(4)*x**Integer(3)*y**Integer(2)])
>>> f.multiplier_spectra(Integer(1))
[0, z3 + 2, z3 + 1, z3, 1, 1]

K = GF(3).algebraic_closure()
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^5 + 2*y^5, 4*x^3*y^2])
f.multiplier_spectra(1)
nth_iterate(P, n, **kwds)[source]

Return the n-th iterate of the point 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 this map’s domain

  • n – positive integer

kwds:

  • normalize – boolean (default: False)

OUTPUT: a point in this map’s codomain

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
sage: Q = P(1,1)
sage: f.nth_iterate(Q,4)
(32768 : 32768)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*y**Integer(2)])
>>> Q = P(Integer(1),Integer(1))
>>> f.nth_iterate(Q,Integer(4))
(32768 : 32768)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
Q = P(1,1)
f.nth_iterate(Q,4)
sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
sage: Q = P(1,1)
sage: f.nth_iterate(Q, 4, normalize=True)
(1 : 1)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*y**Integer(2)])
>>> Q = P(Integer(1),Integer(1))
>>> f.nth_iterate(Q, Integer(4), normalize=True)
(1 : 1)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
Q = P(1,1)
f.nth_iterate(Q, 4, normalize=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*y**Integer(2)])
>>> Q = P(Integer(1),Integer(1))
>>> f.nth_iterate(Q, Integer(4), normalize=True)
(1 : 1)

P.<x,y> = ProjectiveSpace(ZZ,1)
f = DynamicalSystem_projective([x^2 + y^2, 2*y^2])
Q = P(1,1)
f.nth_iterate(Q, 4, normalize=True)
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([x^2, 2*y^2, z^2 - x^2])
sage: Q = P(2,7,1)
sage: f.nth_iterate(Q,2)
(-16/7 : -2744 : 1)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), Integer(2)*y**Integer(2), z**Integer(2) - x**Integer(2)])
>>> Q = P(Integer(2),Integer(7),Integer(1))
>>> f.nth_iterate(Q,Integer(2))
(-16/7 : -2744 : 1)

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2, 2*y^2, z^2 - x^2])
Q = P(2,7,1)
f.nth_iterate(Q,2)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), Integer(2)*y**Integer(2), z**Integer(2) - x**Integer(2)])
>>> Q = P(Integer(2),Integer(7),Integer(1))
>>> f.nth_iterate(Q,Integer(2))
(-16/7 : -2744 : 1)

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2, 2*y^2, z^2 - x^2])
Q = P(2,7,1)
f.nth_iterate(Q,2)
sage: R.<t> = PolynomialRing(QQ)
sage: P.<x,y,z> = ProjectiveSpace(R,2)
sage: f = DynamicalSystem_projective([x^2 + t*y^2, (2-t)*y^2, z^2])
sage: Q = P(2 + t, 7, t)
sage: f.nth_iterate(Q,2)
(t^4 + 2507*t^3 - 6787*t^2 + 10028*t + 16
 : -2401*t^3 + 14406*t^2 - 28812*t + 19208 : t^4)

>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + t*y**Integer(2), (Integer(2)-t)*y**Integer(2), z**Integer(2)])
>>> Q = P(Integer(2) + t, Integer(7), t)
>>> f.nth_iterate(Q,Integer(2))
(t^4 + 2507*t^3 - 6787*t^2 + 10028*t + 16
 : -2401*t^3 + 14406*t^2 - 28812*t + 19208 : t^4)

R.<t> = PolynomialRing(QQ)
P.<x,y,z> = ProjectiveSpace(R,2)
f = DynamicalSystem_projective([x^2 + t*y^2, (2-t)*y^2, z^2])
Q = P(2 + t, 7, t)
f.nth_iterate(Q,2)
>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + t*y**Integer(2), (Integer(2)-t)*y**Integer(2), z**Integer(2)])
>>> Q = P(Integer(2) + t, Integer(7), t)
>>> f.nth_iterate(Q,Integer(2))
(t^4 + 2507*t^3 - 6787*t^2 + 10028*t + 16
 : -2401*t^3 + 14406*t^2 - 28812*t + 19208 : t^4)

R.<t> = PolynomialRing(QQ)
P.<x,y,z> = ProjectiveSpace(R,2)
f = DynamicalSystem_projective([x^2 + t*y^2, (2-t)*y^2, z^2])
Q = P(2 + t, 7, t)
f.nth_iterate(Q,2)
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: X = P.subscheme(x^2-y^2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
sage: f.nth_iterate(X(2,2,3), 3)
(256 : 256 : 6561)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2)-y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.nth_iterate(X(Integer(2),Integer(2),Integer(3)), Integer(3))
(256 : 256 : 6561)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
X = P.subscheme(x^2-y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.nth_iterate(X(2,2,3), 3)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2)-y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.nth_iterate(X(Integer(2),Integer(2),Integer(3)), Integer(3))
(256 : 256 : 6561)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
X = P.subscheme(x^2-y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.nth_iterate(X(2,2,3), 3)
sage: K.<c> = FunctionField(QQ)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^3 - 2*x*y^2 - c*y^3, x*y^2])
sage: f.nth_iterate(P(c,1), 2)
((c^6 - 9*c^4 + 25*c^2 - c - 21)/(c^2 - 3) : 1)

sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([x^2 + 3*y^2, 2*y^2, z^2])
sage: f.nth_iterate(P(2, 7, 1), -2)
Traceback (most recent call last):
...
TypeError: must be a forward orbit

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(2)*x*y**Integer(2) - c*y**Integer(3), x*y**Integer(2)])
>>> f.nth_iterate(P(c,Integer(1)), Integer(2))
((c^6 - 9*c^4 + 25*c^2 - c - 21)/(c^2 - 3) : 1)

>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(3)*y**Integer(2), Integer(2)*y**Integer(2), z**Integer(2)])
>>> f.nth_iterate(P(Integer(2), Integer(7), Integer(1)), -Integer(2))
Traceback (most recent call last):
...
TypeError: must be a forward orbit

K.<c> = FunctionField(QQ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 - 2*x*y^2 - c*y^3, x*y^2])
f.nth_iterate(P(c,1), 2)
P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2 + 3*y^2, 2*y^2, z^2])
f.nth_iterate(P(2, 7, 1), -2)
>>> from sage.all import *
>>> K = FunctionField(QQ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) - Integer(2)*x*y**Integer(2) - c*y**Integer(3), x*y**Integer(2)])
>>> f.nth_iterate(P(c,Integer(1)), Integer(2))
((c^6 - 9*c^4 + 25*c^2 - c - 21)/(c^2 - 3) : 1)

>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(3)*y**Integer(2), Integer(2)*y**Integer(2), z**Integer(2)])
>>> f.nth_iterate(P(Integer(2), Integer(7), Integer(1)), -Integer(2))
Traceback (most recent call last):
...
TypeError: must be a forward orbit

K.<c> = FunctionField(QQ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 - 2*x*y^2 - c*y^3, x*y^2])
f.nth_iterate(P(c,1), 2)
P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2 + 3*y^2, 2*y^2, z^2])
f.nth_iterate(P(2, 7, 1), -2)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
sage: f.nth_iterate(P(0, 1), 3, check=False)
(0 : 0)
sage: f.nth_iterate(P(0, 1), 3)
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.nth_iterate(P(Integer(0), Integer(1)), Integer(3), check=False)
(0 : 0)
>>> f.nth_iterate(P(Integer(0), Integer(1)), Integer(3))
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.nth_iterate(P(0, 1), 3, check=False)
f.nth_iterate(P(0, 1), 3)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.nth_iterate(P(Integer(0), Integer(1)), Integer(3), check=False)
(0 : 0)
>>> f.nth_iterate(P(Integer(0), Integer(1)), Integer(3))
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.nth_iterate(P(0, 1), 3, check=False)
f.nth_iterate(P(0, 1), 3)
sage: P.<x,y> = ProjectiveSpace(ZZ, 1)
sage: f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
sage: f.nth_iterate(P(2,1), 3, normalize=False)
(134217728 : 524288)
sage: f.nth_iterate(P(2,1), 3, normalize=True)
(256 : 1)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.nth_iterate(P(Integer(2),Integer(1)), Integer(3), normalize=False)
(134217728 : 524288)
>>> f.nth_iterate(P(Integer(2),Integer(1)), Integer(3), normalize=True)
(256 : 1)

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.nth_iterate(P(2,1), 3, normalize=False)
f.nth_iterate(P(2,1), 3, normalize=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.nth_iterate(P(Integer(2),Integer(1)), Integer(3), normalize=False)
(134217728 : 524288)
>>> f.nth_iterate(P(Integer(2),Integer(1)), Integer(3), normalize=True)
(256 : 1)

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.nth_iterate(P(2,1), 3, normalize=False)
f.nth_iterate(P(2,1), 3, normalize=True)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem([x + y, y])
sage: Q = (3,1)
sage: f.nth_iterate(Q,0)
(3 : 1)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x + y, y])
>>> Q = (Integer(3),Integer(1))
>>> f.nth_iterate(Q,Integer(0))
(3 : 1)

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem([x + y, y])
Q = (3,1)
f.nth_iterate(Q,0)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x + y, y])
>>> Q = (Integer(3),Integer(1))
>>> f.nth_iterate(Q,Integer(0))
(3 : 1)

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem([x + y, y])
Q = (3,1)
f.nth_iterate(Q,0)
nth_iterate_map(n, normalize=False)[source]

Return the n-th iterate of this dynamical system.

ALGORITHM:

Uses a form of successive squaring to reducing computations.

Todo

This could be improved.

INPUT:

  • n – positive integer

  • normalize – boolean; remove gcd’s during iteration

OUTPUT: a projective dynamical system

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.nth_iterate_map(2)
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^4 + 2*x^2*y^2 + 2*y^4 : y^4)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.nth_iterate_map(Integer(2))
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^4 + 2*x^2*y^2 + 2*y^4 : y^4)

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.nth_iterate_map(2)
sage: P.<x,y> = ProjectiveSpace(CC,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, x*y])
sage: f.nth_iterate_map(3)
Dynamical System of Projective Space of dimension 1
 over Complex Field with 53 bits of precision
  Defn: Defined on coordinates by sending (x : y) to
        (x^8 + (-7.00000000000000)*x^6*y^2 + 13.0000000000000*x^4*y^4
           + (-7.00000000000000)*x^2*y^6 + y^8
         : x^7*y + (-4.00000000000000)*x^5*y^3 + 4.00000000000000*x^3*y^5 - x*y^7)

>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y])
>>> f.nth_iterate_map(Integer(3))
Dynamical System of Projective Space of dimension 1
 over Complex Field with 53 bits of precision
  Defn: Defined on coordinates by sending (x : y) to
        (x^8 + (-7.00000000000000)*x^6*y^2 + 13.0000000000000*x^4*y^4
           + (-7.00000000000000)*x^2*y^6 + y^8
         : x^7*y + (-4.00000000000000)*x^5*y^3 + 4.00000000000000*x^3*y^5 - x*y^7)

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^2 - y^2, x*y])
f.nth_iterate_map(3)
>>> from sage.all import *
>>> P = ProjectiveSpace(CC,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y])
>>> f.nth_iterate_map(Integer(3))
Dynamical System of Projective Space of dimension 1
 over Complex Field with 53 bits of precision
  Defn: Defined on coordinates by sending (x : y) to
        (x^8 + (-7.00000000000000)*x^6*y^2 + 13.0000000000000*x^4*y^4
           + (-7.00000000000000)*x^2*y^6 + y^8
         : x^7*y + (-4.00000000000000)*x^5*y^3 + 4.00000000000000*x^3*y^5 - x*y^7)

P.<x,y> = ProjectiveSpace(CC,1)
f = DynamicalSystem_projective([x^2 - y^2, x*y])
f.nth_iterate_map(3)
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([x^2 - y^2, x*y, z^2 + x^2])
sage: f.nth_iterate_map(2)
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 - 3*x^2*y^2 + y^4 : x^3*y - x*y^3
         : 2*x^4 - 2*x^2*y^2 + y^4 + 2*x^2*z^2 + z^4)

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y, z**Integer(2) + x**Integer(2)])
>>> f.nth_iterate_map(Integer(2))
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 - 3*x^2*y^2 + y^4 : x^3*y - x*y^3
         : 2*x^4 - 2*x^2*y^2 + y^4 + 2*x^2*z^2 + z^4)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 - y^2, x*y, z^2 + x^2])
f.nth_iterate_map(2)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y, z**Integer(2) + x**Integer(2)])
>>> f.nth_iterate_map(Integer(2))
Dynamical System of Projective Space of dimension 2 over Integer Ring
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 - 3*x^2*y^2 + y^4 : x^3*y - x*y^3
         : 2*x^4 - 2*x^2*y^2 + y^4 + 2*x^2*z^2 + z^4)

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 - y^2, x*y, z^2 + x^2])
f.nth_iterate_map(2)
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: X = P.subscheme(x*z-y^2)
sage: f = DynamicalSystem_projective([x^2, x*z, z^2], domain=X)
sage: f.nth_iterate_map(2)                                                  # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Rational Field defined by:
  -y^2 + x*z
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 : x^2*z^2 : z^4)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x*z-y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), x*z, z**Integer(2)], domain=X)
>>> f.nth_iterate_map(Integer(2))                                                  # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Rational Field defined by:
  -y^2 + x*z
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 : x^2*z^2 : z^4)

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x*z-y^2)
f = DynamicalSystem_projective([x^2, x*z, z^2], domain=X)
f.nth_iterate_map(2)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x*z-y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), x*z, z**Integer(2)], domain=X)
>>> f.nth_iterate_map(Integer(2))                                                  # needs sage.rings.function_field
Dynamical System of Closed subscheme of Projective Space of dimension
2 over Rational Field defined by:
  -y^2 + x*z
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^4 : x^2*z^2 : z^4)

P.<x,y,z> = ProjectiveSpace(QQ,2)
X = P.subscheme(x*z-y^2)
f = DynamicalSystem_projective([x^2, x*z, z^2], domain=X)
f.nth_iterate_map(2)                                                  # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([y^2 * z^3, y^3 * z^2, x^5])
sage: f.nth_iterate_map( 5, normalize=True)
Dynamical System of Projective Space of dimension 2 over Rational Field
Defn: Defined on coordinates by sending (x : y : z) to
(y^202*z^443 : x^140*y^163*z^342 : x^645)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([y**Integer(2) * z**Integer(3), y**Integer(3) * z**Integer(2), x**Integer(5)])
>>> f.nth_iterate_map( Integer(5), normalize=True)
Dynamical System of Projective Space of dimension 2 over Rational Field
Defn: Defined on coordinates by sending (x : y : z) to
(y^202*z^443 : x^140*y^163*z^342 : x^645)

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([y^2 * z^3, y^3 * z^2, x^5])
f.nth_iterate_map( 5, normalize=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([y**Integer(2) * z**Integer(3), y**Integer(3) * z**Integer(2), x**Integer(5)])
>>> f.nth_iterate_map( Integer(5), normalize=True)
Dynamical System of Projective Space of dimension 2 over Rational Field
Defn: Defined on coordinates by sending (x : y : z) to
(y^202*z^443 : x^140*y^163*z^342 : x^645)

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([y^2 * z^3, y^3 * z^2, x^5])
f.nth_iterate_map( 5, normalize=True)
nth_preimage_tree(Q, n, **kwds)[source]

Return the n-th pre-image tree rooted at Q.

This map must be an endomorphism of the projective line defined over a number field, algebraic field, or finite field.

INPUT:

  • Q – a point in the domain of this map

  • n – positive integer, the depth of the pre-image tree

kwds:

  • return_points – boolean (default: False); if True, return a list of lists where the index \(i\) is the level of the tree and the elements of the list at that index are the \(i\)-th preimage points as an algebraic element of the splitting field of the polynomial \(f^n - Q = 0\).

  • numerical – boolean (default: False); calculate pre-images numerically. Note if this is set to True, preimage points are displayed as complex numbers.

  • prec – (default: 100) positive integer; the precision of the ComplexField if we compute the preimage points numerically

  • display_labels – boolean (default: True); whether to display vertex labels. Since labels can be very cluttered, can set display_labels to False and use return_points to get a hold of the points themselves, either as algebraic or complex numbers.

  • display_complex – boolean (default: False); display vertex labels as complex numbers. Note if this option is chosen that we must choose an embedding from the splitting field field_def of the \(n\)-th-preimage equation into \(\CC\). We make the choice of the first embedding returned by field_def.embeddings(ComplexField()).

  • digits – positive integer; the number of decimal digits to display for complex numbers. This only applies if display_complex is set to True.

OUTPUT:

If return_points is False, a GraphPlot object representing the \(n\)-th pre-image tree. If return_points is True, a tuple (GP, points), where GP is a GraphPlot object, and points is a list of lists as described above under return_points.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: Q = P(0,1)
sage: f.nth_preimage_tree(Q, 2)                                             # needs sage.plot
GraphPlot object for Digraph on 7 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> Q = P(Integer(0),Integer(1))
>>> f.nth_preimage_tree(Q, Integer(2))                                             # needs sage.plot
GraphPlot object for Digraph on 7 vertices

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
Q = P(0,1)
f.nth_preimage_tree(Q, 2)                                             # needs sage.plot
sage: P.<x,y> = ProjectiveSpace(GF(3), 1)
sage: f = DynamicalSystem_projective([x^2 + x*y + y^2, y^2])
sage: Q = P(0,1)
sage: f.nth_preimage_tree(Q, 2, return_points=True)                         # needs sage.plot
(GraphPlot object for Digraph on 4 vertices,
 [[(0 : 1)], [(1 : 1)], [(0 : 1), (2 : 1)]])

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y + y**Integer(2), y**Integer(2)])
>>> Q = P(Integer(0),Integer(1))
>>> f.nth_preimage_tree(Q, Integer(2), return_points=True)                         # needs sage.plot
(GraphPlot object for Digraph on 4 vertices,
 [[(0 : 1)], [(1 : 1)], [(0 : 1), (2 : 1)]])

P.<x,y> = ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 + x*y + y^2, y^2])
Q = P(0,1)
f.nth_preimage_tree(Q, 2, return_points=True)                         # needs sage.plot
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y + y**Integer(2), y**Integer(2)])
>>> Q = P(Integer(0),Integer(1))
>>> f.nth_preimage_tree(Q, Integer(2), return_points=True)                         # needs sage.plot
(GraphPlot object for Digraph on 4 vertices,
 [[(0 : 1)], [(1 : 1)], [(0 : 1), (2 : 1)]])

P.<x,y> = ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 + x*y + y^2, y^2])
Q = P(0,1)
f.nth_preimage_tree(Q, 2, return_points=True)                         # needs sage.plot
orbit(P, N, **kwds)[source]

Return the orbit of the point 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 initialization if check=True.

INPUT:

  • P – a point in this dynamical system’s 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 this dynamical system’s codomain

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2 - z^2, 2*z^2])
sage: f.orbit(P(1,2,1), 3)
[(1 : 2 : 1), (5 : 3 : 2), (34 : 5 : 8), (1181 : -39 : 128)]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2) - z**Integer(2), Integer(2)*z**Integer(2)])
>>> f.orbit(P(Integer(1),Integer(2),Integer(1)), Integer(3))
[(1 : 2 : 1), (5 : 3 : 2), (34 : 5 : 8), (1181 : -39 : 128)]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 + y^2, y^2 - z^2, 2*z^2])
f.orbit(P(1,2,1), 3)
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2 - z^2, 2*z^2])
sage: f.orbit(P(1,2,1), [2,4])
[(34 : 5 : 8), (1181 : -39 : 128), (1396282 : -14863 : 32768)]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2) - z**Integer(2), Integer(2)*z**Integer(2)])
>>> f.orbit(P(Integer(1),Integer(2),Integer(1)), [Integer(2),Integer(4)])
[(34 : 5 : 8), (1181 : -39 : 128), (1396282 : -14863 : 32768)]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 + y^2, y^2 - z^2, 2*z^2])
f.orbit(P(1,2,1), [2,4])
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2) - z**Integer(2), Integer(2)*z**Integer(2)])
>>> f.orbit(P(Integer(1),Integer(2),Integer(1)), [Integer(2),Integer(4)])
[(34 : 5 : 8), (1181 : -39 : 128), (1396282 : -14863 : 32768)]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([x^2 + y^2, y^2 - z^2, 2*z^2])
f.orbit(P(1,2,1), [2,4])
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: X = P.subscheme(x^2 - y^2)
sage: f = DynamicalSystem_projective([x^2, y^2, x*z], domain=X)
sage: f.orbit(X(2,2,3), 3, normalize=True)
[(2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3)]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), x*z], domain=X)
>>> f.orbit(X(Integer(2),Integer(2),Integer(3)), Integer(3), normalize=True)
[(2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3)]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, x*z], domain=X)
f.orbit(X(2,2,3), 3, normalize=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), x*z], domain=X)
>>> f.orbit(X(Integer(2),Integer(2),Integer(3)), Integer(3), normalize=True)
[(2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3)]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, x*z], domain=X)
f.orbit(X(2,2,3), 3, normalize=True)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.orbit(P.point([1,2], False), 4, check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.orbit(P.point([Integer(1),Integer(2)], False), Integer(4), check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.orbit(P.point([1,2], False), 4, check=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.orbit(P.point([Integer(1),Integer(2)], False), Integer(4), check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.orbit(P.point([1,2], False), 4, check=False)
sage: K.<c> = FunctionField(QQ)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
sage: f.orbit(P(0,1), 3)
[(0 : 1), (c : 1), (c^2 + c : 1), (c^4 + 2*c^3 + c^2 + c : 1)]

>>> from sage.all import *
>>> K = FunctionField(QQ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.orbit(P(Integer(0),Integer(1)), Integer(3))
[(0 : 1), (c : 1), (c^2 + c : 1), (c^4 + 2*c^3 + c^2 + c : 1)]

K.<c> = FunctionField(QQ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.orbit(P(0,1), 3)
>>> from sage.all import *
>>> K = FunctionField(QQ, names=('c',)); (c,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.orbit(P(Integer(0),Integer(1)), Integer(3))
[(0 : 1), (c : 1), (c^2 + c : 1), (c^4 + 2*c^3 + c^2 + c : 1)]

K.<c> = FunctionField(QQ)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.orbit(P(0,1), 3)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2], domain=P)
sage: f.orbit(P.point([1, 2], False), 4, check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit(P.point([Integer(1), Integer(2)], False), Integer(4), check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2], domain=P)
f.orbit(P.point([1, 2], False), 4, check=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit(P.point([Integer(1), Integer(2)], False), Integer(4), check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2], domain=P)
f.orbit(P.point([1, 2], False), 4, check=False)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2, 2*y^2], domain=P)
sage: f.orbit(P(2, 1),[-1, 4])
Traceback (most recent call last):
...
TypeError: orbit bounds must be nonnegative
sage: f.orbit(P(2, 1), 0.1)
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral RealNumber to Integer

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2), Integer(2)*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(2), Integer(1)),[-Integer(1), Integer(4)])
Traceback (most recent call last):
...
TypeError: orbit bounds must be nonnegative
>>> f.orbit(P(Integer(2), Integer(1)), RealNumber('0.1'))
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral RealNumber to Integer

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2, 2*y^2], domain=P)
f.orbit(P(2, 1),[-1, 4])
f.orbit(P(2, 1), 0.1)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2), Integer(2)*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(2), Integer(1)),[-Integer(1), Integer(4)])
Traceback (most recent call last):
...
TypeError: orbit bounds must be nonnegative
>>> f.orbit(P(Integer(2), Integer(1)), RealNumber('0.1'))
Traceback (most recent call last):
...
TypeError: Attempt to coerce non-integral RealNumber to Integer

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2, 2*y^2], domain=P)
f.orbit(P(2, 1),[-1, 4])
f.orbit(P(2, 1), 0.1)
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
sage: f.orbit(P(0, 1), 3)
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero
sage: f.orbit(P(0, 1), 3, check=False)
[(0 : 1), (0 : 0), (0 : 0), (0 : 0)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(0), Integer(1)), Integer(3))
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero
>>> f.orbit(P(Integer(0), Integer(1)), Integer(3), check=False)
[(0 : 1), (0 : 0), (0 : 0), (0 : 0)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.orbit(P(0, 1), 3)
f.orbit(P(0, 1), 3, check=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(0), Integer(1)), Integer(3))
Traceback (most recent call last):
...
ValueError: [0, 0] does not define a valid projective point since all entries are zero
>>> f.orbit(P(Integer(0), Integer(1)), Integer(3), check=False)
[(0 : 1), (0 : 0), (0 : 0), (0 : 0)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.orbit(P(0, 1), 3)
f.orbit(P(0, 1), 3, check=False)
sage: P.<x,y> = ProjectiveSpace(ZZ, 1)
sage: f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
sage: f.orbit(P(2,1), 3, normalize=False)
[(2 : 1), (8 : 2), (512 : 32), (134217728 : 524288)]
sage: f.orbit(P(2, 1), 3, normalize=True)
[(2 : 1), (4 : 1), (16 : 1), (256 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(2),Integer(1)), Integer(3), normalize=False)
[(2 : 1), (8 : 2), (512 : 32), (134217728 : 524288)]
>>> f.orbit(P(Integer(2), Integer(1)), Integer(3), normalize=True)
[(2 : 1), (4 : 1), (16 : 1), (256 : 1)]

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.orbit(P(2,1), 3, normalize=False)
f.orbit(P(2, 1), 3, normalize=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), x*y**Integer(2)], domain=P)
>>> f.orbit(P(Integer(2),Integer(1)), Integer(3), normalize=False)
[(2 : 1), (8 : 2), (512 : 32), (134217728 : 524288)]
>>> f.orbit(P(Integer(2), Integer(1)), Integer(3), normalize=True)
[(2 : 1), (4 : 1), (16 : 1), (256 : 1)]

P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^3, x*y^2], domain=P)
f.orbit(P(2,1), 3, normalize=False)
f.orbit(P(2, 1), 3, normalize=True)
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([x^2, y^2, x*z])
sage: f.orbit((2/3, 1/3), 3)
[(2/3 : 1/3 : 1), (2/3 : 1/6 : 1), (2/3 : 1/24 : 1), (2/3 : 1/384 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), x*z])
>>> f.orbit((Integer(2)/Integer(3), Integer(1)/Integer(3)), Integer(3))
[(2/3 : 1/3 : 1), (2/3 : 1/6 : 1), (2/3 : 1/24 : 1), (2/3 : 1/384 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2, y^2, x*z])
f.orbit((2/3, 1/3), 3)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), x*z])
>>> f.orbit((Integer(2)/Integer(3), Integer(1)/Integer(3)), Integer(3))
[(2/3 : 1/3 : 1), (2/3 : 1/6 : 1), (2/3 : 1/24 : 1), (2/3 : 1/384 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([x^2, y^2, x*z])
f.orbit((2/3, 1/3), 3)
periodic_points(n, minimal=True, formal=False, R=None, algorithm='variety', return_scheme=False)[source]

Compute the periodic points of period n of this dynamical system defined over the ring R or the base ring of the map.

This can be done either by finding the rational points on the variety defining the points of period n, or, for finite fields, finding the cycle of appropriate length in the cyclegraph. For small cardinality fields, the cyclegraph algorithm is effective for any map and length cycle, but is slow when the cyclegraph is large. The variety algorithm is good for small period, degree, and dimension, but is slow as the defining equations of the variety get more complicated.

For rational maps, where there are potentially infinitely many periodic points of a given period, you must use the return_scheme option. Note that this scheme will include the indeterminacy locus.

INPUT:

  • n – positive integer

  • minimal – boolean (default: True); True specifies to find only the periodic points of minimal period n and False specifies to find all periodic points of period n

  • formal – boolean (default: False); True specifies to find the formal periodic points only. The formal periodic points are the points in the support of the dynatomic cycle.

  • R – (optional) a commutative ring. Defaults to the base ring of this map

  • algorithm – (default: 'variety') must be one of the following:

    • 'variety' – find the rational points on the appropriate variety

    • 'cyclegraph' – find the cycles from the cycle graph

  • return_scheme – return a subscheme of the ambient space that defines the n th periodic points

OUTPUT:

A list of periodic points of this map or the subscheme defining the periodic points.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([x^2 - x*y + y^2, x^2 - y^2 + x*y])
sage: f.periodic_points(1)
[(-0.50000000000000000? - 0.866025403784439?*I : 1),
 (-0.50000000000000000? + 0.866025403784439?*I : 1),
 (1 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - x*y + y**Integer(2), x**Integer(2) - y**Integer(2) + x*y])
>>> f.periodic_points(Integer(1))
[(-0.50000000000000000? - 0.866025403784439?*I : 1),
 (-0.50000000000000000? + 0.866025403784439?*I : 1),
 (1 : 1)]

# needs sage.rings.number_field
set_verbose(None)
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^2 - x*y + y^2, x^2 - y^2 + x*y])
f.periodic_points(1)
sage: # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QuadraticField(5,'t'), 2)
sage: f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - z^2, z^2])
sage: f.periodic_points(2)
[(-5/4 : -1 : 1), (-5/4 : -1/2*t + 1/2 : 1), (-5/4 : 0 : 1),
 (-5/4 : 1/2*t + 1/2 : 1), (-3/4 : -1 : 1), (-3/4 : 0 : 1),
 (1/4 : -1 : 1), (1/4 : -1/2*t + 1/2 : 1), (1/4 : 0 : 1),
 (1/4 : 1/2*t + 1/2 : 1), (7/4 : -1 : 1), (7/4 : 0 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QuadraticField(Integer(5),'t'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2))
[(-5/4 : -1 : 1), (-5/4 : -1/2*t + 1/2 : 1), (-5/4 : 0 : 1),
 (-5/4 : 1/2*t + 1/2 : 1), (-3/4 : -1 : 1), (-3/4 : 0 : 1),
 (1/4 : -1 : 1), (1/4 : -1/2*t + 1/2 : 1), (1/4 : 0 : 1),
 (1/4 : 1/2*t + 1/2 : 1), (7/4 : -1 : 1), (7/4 : 0 : 1)]

# needs sage.rings.number_field
P.<x,y,z> = ProjectiveSpace(QuadraticField(5,'t'), 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - z^2, z^2])
f.periodic_points(2)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QuadraticField(Integer(5),'t'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2))
[(-5/4 : -1 : 1), (-5/4 : -1/2*t + 1/2 : 1), (-5/4 : 0 : 1),
 (-5/4 : 1/2*t + 1/2 : 1), (-3/4 : -1 : 1), (-3/4 : 0 : 1),
 (1/4 : -1 : 1), (1/4 : -1/2*t + 1/2 : 1), (1/4 : 0 : 1),
 (1/4 : 1/2*t + 1/2 : 1), (7/4 : -1 : 1), (7/4 : 0 : 1)]

# needs sage.rings.number_field
P.<x,y,z> = ProjectiveSpace(QuadraticField(5,'t'), 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - z^2, z^2])
f.periodic_points(2)
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
sage: f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2) , z**Integer(2)])
>>> f.periodic_points(Integer(2), formal=True)                                     # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2) , z**Integer(2)])
>>> f.periodic_points(Integer(2), formal=True)                                     # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: w = QQ['w'].0
sage: K = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1,'s')
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sage: sorted(f.periodic_points(1), key=str)                                 # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> w = QQ['w'].gen(0)
>>> K = NumberField(w**Integer(6) - Integer(3)*w**Integer(5) + Integer(5)*w**Integer(4) - Integer(5)*w**Integer(3) + Integer(5)*w**Integer(2) - Integer(3)*w + Integer(1),'s')
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + z**Integer(2), y**Integer(2) + x**Integer(2), z**Integer(2) + y**Integer(2)])
>>> sorted(f.periodic_points(Integer(1)), key=str)                                 # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

# needs sage.rings.number_field
w = QQ['w'].0
K = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1,'s')
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sorted(f.periodic_points(1), key=str)                                 # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> w = QQ['w'].gen(0)
>>> K = NumberField(w**Integer(6) - Integer(3)*w**Integer(5) + Integer(5)*w**Integer(4) - Integer(5)*w**Integer(3) + Integer(5)*w**Integer(2) - Integer(3)*w + Integer(1),'s')
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + z**Integer(2), y**Integer(2) + x**Integer(2), z**Integer(2) + y**Integer(2)])
>>> sorted(f.periodic_points(Integer(1)), key=str)                                 # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

# needs sage.rings.number_field
w = QQ['w'].0
K = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1,'s')
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sorted(f.periodic_points(1), key=str)                                 # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sage: f.periodic_points(2, False)                                           # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (-3/4 : -1 : 1),
 (-3/4 : 2 : 1), (0 : 1 : 0), (1/4 : -1 : 1), (1/4 : 2 : 1),
 (1 : 0 : 0), (1 : 1 : 0), (7/4 : -1 : 1), (7/4 : 2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2), False)                                           # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (-3/4 : -1 : 1),
 (-3/4 : 2 : 1), (0 : 1 : 0), (1/4 : -1 : 1), (1/4 : 2 : 1),
 (1 : 0 : 0), (1 : 1 : 0), (7/4 : -1 : 1), (7/4 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
f.periodic_points(2, False)                                           # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2), False)                                           # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (-3/4 : -1 : 1),
 (-3/4 : 2 : 1), (0 : 1 : 0), (1/4 : -1 : 1), (1/4 : 2 : 1),
 (1 : 0 : 0), (1 : 1 : 0), (7/4 : -1 : 1), (7/4 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
f.periodic_points(2, False)                                           # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sage: f.periodic_points(2)                                                  # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (1/4 : -1 : 1), (1/4 : 2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2))                                                  # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (1/4 : -1 : 1), (1/4 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
f.periodic_points(2)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2))                                                  # needs sage.rings.function_field
[(-5/4 : -1 : 1), (-5/4 : 2 : 1), (1/4 : -1 : 1), (1/4 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
f.periodic_points(2)                                                  # needs sage.rings.function_field
sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(ZZ, 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.periodic_points(2, R=QQbar, minimal=False)                          # needs sage.rings.number_field
[(-0.50000000000000000? - 1.322875655532296?*I : 1),
 (-0.50000000000000000? + 1.322875655532296?*I : 1),
 (0.50000000000000000? - 0.866025403784439?*I : 1),
 (0.50000000000000000? + 0.866025403784439?*I : 1),
 (1 : 0)]

>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=QQbar, minimal=False)                          # needs sage.rings.number_field
[(-0.50000000000000000? - 1.322875655532296?*I : 1),
 (-0.50000000000000000? + 1.322875655532296?*I : 1),
 (0.50000000000000000? - 0.866025403784439?*I : 1),
 (0.50000000000000000? + 0.866025403784439?*I : 1),
 (1 : 0)]

set_verbose(None)
P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.periodic_points(2, R=QQbar, minimal=False)                          # needs sage.rings.number_field
>>> from sage.all import *
>>> set_verbose(None)
>>> P = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=QQbar, minimal=False)                          # needs sage.rings.number_field
[(-0.50000000000000000? - 1.322875655532296?*I : 1),
 (-0.50000000000000000? + 1.322875655532296?*I : 1),
 (0.50000000000000000? - 0.866025403784439?*I : 1),
 (0.50000000000000000? + 0.866025403784439?*I : 1),
 (1 : 0)]

set_verbose(None)
P.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.periodic_points(2, R=QQbar, minimal=False)                          # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 3/4*z^2, y^2 - 3/4*z^2, z^2])
sage: f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
[(-1/2 : -1/2 : 1), (-1/2 : 3/2 : 1), (3/2 : -1/2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*z**Integer(2), y**Integer(2) - Integer(3)/Integer(4)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2), formal=True)                                     # needs sage.rings.function_field
[(-1/2 : -1/2 : 1), (-1/2 : 3/2 : 1), (3/2 : -1/2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*z^2, y^2 - 3/4*z^2, z^2])
f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*z**Integer(2), y**Integer(2) - Integer(3)/Integer(4)*z**Integer(2), z**Integer(2)])
>>> f.periodic_points(Integer(2), formal=True)                                     # needs sage.rings.function_field
[(-1/2 : -1/2 : 1), (-1/2 : 3/2 : 1), (3/2 : -1/2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*z^2, y^2 - 3/4*z^2, z^2])
f.periodic_points(2, formal=True)                                     # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(GF(307), 1)
sage: f = DynamicalSystem_projective([x^10 + y^10, y^10])
sage: f.periodic_points(16, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(69 : 1), (185 : 1), (120 : 1), (136 : 1), (97 : 1), (183 : 1),
 (170 : 1), (105 : 1), (274 : 1), (275 : 1), (154 : 1), (156 : 1),
 (87 : 1), (95 : 1), (161 : 1), (128 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(307)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(10) + y**Integer(10), y**Integer(10)])
>>> f.periodic_points(Integer(16), minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(69 : 1), (185 : 1), (120 : 1), (136 : 1), (97 : 1), (183 : 1),
 (170 : 1), (105 : 1), (274 : 1), (275 : 1), (154 : 1), (156 : 1),
 (87 : 1), (95 : 1), (161 : 1), (128 : 1)]

P.<x,y> = ProjectiveSpace(GF(307), 1)
f = DynamicalSystem_projective([x^10 + y^10, y^10])
f.periodic_points(16, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(307)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(10) + y**Integer(10), y**Integer(10)])
>>> f.periodic_points(Integer(16), minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(69 : 1), (185 : 1), (120 : 1), (136 : 1), (97 : 1), (183 : 1),
 (170 : 1), (105 : 1), (274 : 1), (275 : 1), (154 : 1), (156 : 1),
 (87 : 1), (95 : 1), (161 : 1), (128 : 1)]

P.<x,y> = ProjectiveSpace(GF(307), 1)
f = DynamicalSystem_projective([x^10 + y^10, y^10])
f.periodic_points(16, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
sage: # needs sage.rings.finite_rings
sage: P.<x,y> = ProjectiveSpace(GF(13^2, 't'), 1)
sage: f = DynamicalSystem_projective([x^3 + 3*y^3, x^2*y])
sage: f.periodic_points(30, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(t + 3 : 1), (6*t + 6 : 1), (7*t + 1 : 1), (2*t + 8 : 1),
 (3*t + 4 : 1), (10*t + 12 : 1), (8*t + 10 : 1), (5*t + 11 : 1),
 (7*t + 4 : 1), (4*t + 8 : 1), (9*t + 1 : 1), (2*t + 2 : 1),
 (11*t + 9 : 1), (5*t + 7 : 1), (t + 10 : 1), (12*t + 4 : 1),
 (7*t + 12 : 1), (6*t + 8 : 1), (11*t + 10 : 1), (10*t + 7 : 1),
 (3*t + 9 : 1), (5*t + 5 : 1), (8*t + 3 : 1), (6*t + 11 : 1),
 (9*t + 12 : 1), (4*t + 10 : 1), (11*t + 4 : 1), (2*t + 7 : 1),
 (8*t + 12 : 1), (12*t + 11 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(13)**Integer(2), 't'), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(3)*y**Integer(3), x**Integer(2)*y])
>>> f.periodic_points(Integer(30), minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(t + 3 : 1), (6*t + 6 : 1), (7*t + 1 : 1), (2*t + 8 : 1),
 (3*t + 4 : 1), (10*t + 12 : 1), (8*t + 10 : 1), (5*t + 11 : 1),
 (7*t + 4 : 1), (4*t + 8 : 1), (9*t + 1 : 1), (2*t + 2 : 1),
 (11*t + 9 : 1), (5*t + 7 : 1), (t + 10 : 1), (12*t + 4 : 1),
 (7*t + 12 : 1), (6*t + 8 : 1), (11*t + 10 : 1), (10*t + 7 : 1),
 (3*t + 9 : 1), (5*t + 5 : 1), (8*t + 3 : 1), (6*t + 11 : 1),
 (9*t + 12 : 1), (4*t + 10 : 1), (11*t + 4 : 1), (2*t + 7 : 1),
 (8*t + 12 : 1), (12*t + 11 : 1)]

# needs sage.rings.finite_rings
P.<x,y> = ProjectiveSpace(GF(13^2, 't'), 1)
f = DynamicalSystem_projective([x^3 + 3*y^3, x^2*y])
f.periodic_points(30, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(13)**Integer(2), 't'), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(3)*y**Integer(3), x**Integer(2)*y])
>>> f.periodic_points(Integer(30), minimal=True, algorithm='cyclegraph')           # needs sage.graphs
[(t + 3 : 1), (6*t + 6 : 1), (7*t + 1 : 1), (2*t + 8 : 1),
 (3*t + 4 : 1), (10*t + 12 : 1), (8*t + 10 : 1), (5*t + 11 : 1),
 (7*t + 4 : 1), (4*t + 8 : 1), (9*t + 1 : 1), (2*t + 2 : 1),
 (11*t + 9 : 1), (5*t + 7 : 1), (t + 10 : 1), (12*t + 4 : 1),
 (7*t + 12 : 1), (6*t + 8 : 1), (11*t + 10 : 1), (10*t + 7 : 1),
 (3*t + 9 : 1), (5*t + 5 : 1), (8*t + 3 : 1), (6*t + 11 : 1),
 (9*t + 12 : 1), (4*t + 10 : 1), (11*t + 4 : 1), (2*t + 7 : 1),
 (8*t + 12 : 1), (12*t + 11 : 1)]

# needs sage.rings.finite_rings
P.<x,y> = ProjectiveSpace(GF(13^2, 't'), 1)
f = DynamicalSystem_projective([x^3 + 3*y^3, x^2*y])
f.periodic_points(30, minimal=True, algorithm='cyclegraph')           # needs sage.graphs
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([3*x^2 + 5*y^2, y^2])
sage: f.periodic_points(2, R=GF(3), minimal=False)                          # needs sage.rings.function_field
[(2 : 1)]
sage: f.periodic_points(2, R=GF(7))                                         # needs sage.rings.function_field
[]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2) + Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=GF(Integer(3)), minimal=False)                          # needs sage.rings.function_field
[(2 : 1)]
>>> f.periodic_points(Integer(2), R=GF(Integer(7)))                                         # needs sage.rings.function_field
[]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([3*x^2 + 5*y^2, y^2])
f.periodic_points(2, R=GF(3), minimal=False)                          # needs sage.rings.function_field
f.periodic_points(2, R=GF(7))                                         # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2) + Integer(5)*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=GF(Integer(3)), minimal=False)                          # needs sage.rings.function_field
[(2 : 1)]
>>> f.periodic_points(Integer(2), R=GF(Integer(7)))                                         # needs sage.rings.function_field
[]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([3*x^2 + 5*y^2, y^2])
f.periodic_points(2, R=GF(3), minimal=False)                          # needs sage.rings.function_field
f.periodic_points(2, R=GF(7))                                         # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, x*y, z^2])
sage: f.periodic_points(1)                                                  # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: use return_scheme=True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y, z**Integer(2)])
>>> f.periodic_points(Integer(1))                                                  # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: use return_scheme=True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, x*y, z^2])
f.periodic_points(1)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y, z**Integer(2)])
>>> f.periodic_points(Integer(1))                                                  # needs sage.rings.function_field
Traceback (most recent call last):
...
TypeError: use return_scheme=True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, x*y, z^2])
f.periodic_points(1)                                                  # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<u> = NumberField(x^2 - x + 3)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: X = P.subscheme(2*x - y)
sage: f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
....:                                domain=X)
sage: f.periodic_points(2)                                                  # needs sage.rings.function_field
[(-1/5*u - 1/5 : -2/5*u - 2/5 : 1), (1/5*u - 2/5 : 2/5*u - 4/5 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(3), names=('u',)); (u,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*x - y)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(2)*(x**Integer(2) - y**Integer(2)), y**Integer(2) - z**Integer(2)],
...                                domain=X)
>>> f.periodic_points(Integer(2))                                                  # needs sage.rings.function_field
[(-1/5*u - 1/5 : -2/5*u - 2/5 : 1), (1/5*u - 2/5 : 2/5*u - 4/5 : 1)]

# needs sage.rings.number_field
R.<x> = QQ[]
K.<u> = NumberField(x^2 - x + 3)
P.<x,y,z> = ProjectiveSpace(K, 2)
X = P.subscheme(2*x - y)
f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
                               domain=X)
f.periodic_points(2)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(3), names=('u',)); (u,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*x - y)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(2)*(x**Integer(2) - y**Integer(2)), y**Integer(2) - z**Integer(2)],
...                                domain=X)
>>> f.periodic_points(Integer(2))                                                  # needs sage.rings.function_field
[(-1/5*u - 1/5 : -2/5*u - 2/5 : 1), (1/5*u - 2/5 : 2/5*u - 4/5 : 1)]

# needs sage.rings.number_field
R.<x> = QQ[]
K.<u> = NumberField(x^2 - x + 3)
P.<x,y,z> = ProjectiveSpace(K, 2)
X = P.subscheme(2*x - y)
f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
                               domain=X)
f.periodic_points(2)                                                  # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - y^2, x^2 - z^2, y^2 - z^2])
sage: f.periodic_points(1)                                                  # needs sage.rings.function_field
[(-1 : 0 : 1)]
sage: f.periodic_points(1, return_scheme=True)
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  -x^3 + x^2*y - y^3 + x*z^2,
  -x*y^2 + x^2*z - y^2*z + x*z^2,
  -y^3 + x^2*z + y*z^2 - z^3

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x**Integer(2) - z**Integer(2), y**Integer(2) - z**Integer(2)])
>>> f.periodic_points(Integer(1))                                                  # needs sage.rings.function_field
[(-1 : 0 : 1)]
>>> f.periodic_points(Integer(1), return_scheme=True)
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  -x^3 + x^2*y - y^3 + x*z^2,
  -x*y^2 + x^2*z - y^2*z + x*z^2,
  -y^3 + x^2*z + y*z^2 - z^3

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - y^2, x^2 - z^2, y^2 - z^2])
f.periodic_points(1)                                                  # needs sage.rings.function_field
f.periodic_points(1, return_scheme=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x**Integer(2) - z**Integer(2), y**Integer(2) - z**Integer(2)])
>>> f.periodic_points(Integer(1))                                                  # needs sage.rings.function_field
[(-1 : 0 : 1)]
>>> f.periodic_points(Integer(1), return_scheme=True)
Closed subscheme of Projective Space of dimension 2 over Rational Field
defined by:
  -x^3 + x^2*y - y^3 + x*z^2,
  -x*y^2 + x^2*z - y^2*z + x*z^2,
  -y^3 + x^2*z + y*z^2 - z^3

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - y^2, x^2 - z^2, y^2 - z^2])
f.periodic_points(1)                                                  # needs sage.rings.function_field
f.periodic_points(1, return_scheme=True)
sage: P.<x,y>=ProjectiveSpace(GF(3), 1)
sage: f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: f.periodic_points(2, R=GF(3^2,'t'))                                   # needs sage.rings.finite_rings
[(t + 2 : 1), (2*t : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=GF(Integer(3)**Integer(2),'t'))                                   # needs sage.rings.finite_rings
[(t + 2 : 1), (2*t : 1)]

P.<x,y>=ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.periodic_points(2, R=GF(3^2,'t'))                                   # needs sage.rings.finite_rings
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), R=GF(Integer(3)**Integer(2),'t'))                                   # needs sage.rings.finite_rings
[(t + 2 : 1), (2*t : 1)]

P.<x,y>=ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.periodic_points(2, R=GF(3^2,'t'))                                   # needs sage.rings.finite_rings
sage: S.<c> = QQ[]
sage: R.<x,y> = PolynomialRing(S, 2)
sage: P = ProjectiveSpace(R)
sage: f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
sage: f.periodic_points(2, return_scheme=True)                              # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
Polynomial Ring in c over Rational Field defined by:
  x^2 + x*y + (c + 1)*y^2

>>> from sage.all import *
>>> S = QQ['c']; (c,) = S._first_ngens(1)
>>> R = PolynomialRing(S, Integer(2), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), return_scheme=True)                              # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
Polynomial Ring in c over Rational Field defined by:
  x^2 + x*y + (c + 1)*y^2

S.<c> = QQ[]
R.<x,y> = PolynomialRing(S, 2)
P = ProjectiveSpace(R)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.periodic_points(2, return_scheme=True)                              # needs sage.rings.function_field
>>> from sage.all import *
>>> S = QQ['c']; (c,) = S._first_ngens(1)
>>> R = PolynomialRing(S, Integer(2), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.periodic_points(Integer(2), return_scheme=True)                              # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
Polynomial Ring in c over Rational Field defined by:
  x^2 + x*y + (c + 1)*y^2

S.<c> = QQ[]
R.<x,y> = PolynomialRing(S, 2)
P = ProjectiveSpace(R)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.periodic_points(2, return_scheme=True)                              # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(ZZ, 2)
sage: f = DynamicalSystem([x^2 - 2*y^2, y^2, z^2])
sage: X = f.periodic_points(2, minimal=False, formal=True,  # long time
....:                       return_scheme=True)
sage: len(X.defining_polynomials())                         # long time
19

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2), z**Integer(2)])
>>> X = f.periodic_points(Integer(2), minimal=False, formal=True,  # long time
...                       return_scheme=True)
>>> len(X.defining_polynomials())                         # long time
19

P.<x,y,z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem([x^2 - 2*y^2, y^2, z^2])
X = f.periodic_points(2, minimal=False, formal=True,  # long time
                      return_scheme=True)
len(X.defining_polynomials())                         # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2), z**Integer(2)])
>>> X = f.periodic_points(Integer(2), minimal=False, formal=True,  # long time
...                       return_scheme=True)
>>> len(X.defining_polynomials())                         # long time
19

P.<x,y,z> = ProjectiveSpace(ZZ, 2)
f = DynamicalSystem([x^2 - 2*y^2, y^2, z^2])
X = f.periodic_points(2, minimal=False, formal=True,  # long time
                      return_scheme=True)
len(X.defining_polynomials())                         # long time
possible_periods(**kwds)[source]

Return the set of possible periods for rational periodic points of this dynamical system.

Must be defined over \(\ZZ\) or \(\QQ\).

ALGORITHM:

Calls self.possible_periods() modulo all primes of good reduction in range prime_bound. Return the intersection of those lists.

INPUT: keyword arguments:

  • prime_bound – (default: [1, 20]) a list or tuple of two positive integers or an integer for the upper bound

  • bad_primes – (optional) a list or tuple of integer primes, the primes of bad reduction

  • ncpus – (default: all cpus) number of cpus to use in parallel

OUTPUT: list of positive integers

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
sage: f.possible_periods(ncpus=1)                                           # needs sage.rings.function_field
[1, 3]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.possible_periods(ncpus=Integer(1))                                           # needs sage.rings.function_field
[1, 3]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.possible_periods(ncpus=1)                                           # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(1,QQ)
sage: f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
sage: f.possible_periods(prime_bound=[1,5])                                 # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no primes of good reduction in that range
sage: f.possible_periods(prime_bound=[1,10])                                # needs sage.rings.function_field
[1, 4, 12]
sage: f.possible_periods(prime_bound=[1,20])                                # needs sage.rings.function_field
[1, 4]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(3) - Integer(53)*x*y**Integer(2) + Integer(24)*y**Integer(3), Integer(24)*y**Integer(3)])
>>> f.possible_periods(prime_bound=[Integer(1),Integer(5)])                                 # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no primes of good reduction in that range
>>> f.possible_periods(prime_bound=[Integer(1),Integer(10)])                                # needs sage.rings.function_field
[1, 4, 12]
>>> f.possible_periods(prime_bound=[Integer(1),Integer(20)])                                # needs sage.rings.function_field
[1, 4]

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
f.possible_periods(prime_bound=[1,5])                                 # needs sage.rings.function_field
f.possible_periods(prime_bound=[1,10])                                # needs sage.rings.function_field
f.possible_periods(prime_bound=[1,20])                                # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(3) - Integer(53)*x*y**Integer(2) + Integer(24)*y**Integer(3), Integer(24)*y**Integer(3)])
>>> f.possible_periods(prime_bound=[Integer(1),Integer(5)])                                 # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no primes of good reduction in that range
>>> f.possible_periods(prime_bound=[Integer(1),Integer(10)])                                # needs sage.rings.function_field
[1, 4, 12]
>>> f.possible_periods(prime_bound=[Integer(1),Integer(20)])                                # needs sage.rings.function_field
[1, 4]

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
f.possible_periods(prime_bound=[1,5])                                 # needs sage.rings.function_field
f.possible_periods(prime_bound=[1,10])                                # needs sage.rings.function_field
f.possible_periods(prime_bound=[1,20])                                # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
....:                                 5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
sage: f.possible_periods(prime_bound=10)                                    # needs sage.rings.function_field
[1, 2, 6, 20, 42, 60, 140, 420]
sage: f.possible_periods(prime_bound=20) # long time
[1, 20]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> f.possible_periods(prime_bound=Integer(10))                                    # needs sage.rings.function_field
[1, 2, 6, 20, 42, 60, 140, 420]
>>> f.possible_periods(prime_bound=Integer(20)) # long time
[1, 20]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
f.possible_periods(prime_bound=10)                                    # needs sage.rings.function_field
f.possible_periods(prime_bound=20) # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> f.possible_periods(prime_bound=Integer(10))                                    # needs sage.rings.function_field
[1, 2, 6, 20, 42, 60, 140, 420]
>>> f.possible_periods(prime_bound=Integer(20)) # long time
[1, 20]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
f.possible_periods(prime_bound=10)                                    # needs sage.rings.function_field
f.possible_periods(prime_bound=20) # long time
postcritical_set(check=True)[source]

Return the postcritical set of this dynamical system.

Raises an error if this dynamical system is not postcritically finite.

The postcritical set is union of points which are in the forward orbits of the critical points. In other words, the set of points \(Q\) such that \(f^n(P) = Q\) for some positive integer \(n\) and critical point \(P\), where \(f\) is this map.

Note that the orbit of all critical points is found, even if the critical points are defined in an extension of the base ring of this dynamical system. We extend to the field defined by f.field_of_definition_critical(), where f is this map.

INPUT:

  • check – boolean (default: True); whether to check if this dynamical system is postcritically finite or not

OUTPUT: the set of postcritical points

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([x^3 - 3/2* x*y^2, y^3])
sage: f.postcritical_set()                                                  # needs sage.rings.number_field
[(1/2*a : 1), (-1/2*a : 1), (1 : 0)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(3) - Integer(3)/Integer(2)* x*y**Integer(2), y**Integer(3)])
>>> f.postcritical_set()                                                  # needs sage.rings.number_field
[(1/2*a : 1), (-1/2*a : 1), (1 : 0)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([x^3 - 3/2* x*y^2, y^3])
f.postcritical_set()                                                  # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([3*x^3 - 9/2* x^2*y+y^3, y^3])
sage: f.postcritical_set(check=False)                                       # needs sage.rings.number_field
[(1 : 1), (-1/2 : 1), (1 : 0)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(3)*x**Integer(3) - Integer(9)/Integer(2)* x**Integer(2)*y+y**Integer(3), y**Integer(3)])
>>> f.postcritical_set(check=False)                                       # needs sage.rings.number_field
[(1 : 1), (-1/2 : 1), (1 : 0)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([3*x^3 - 9/2* x^2*y+y^3, y^3])
f.postcritical_set(check=False)                                       # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(3)*x**Integer(3) - Integer(9)/Integer(2)* x**Integer(2)*y+y**Integer(3), y**Integer(3)])
>>> f.postcritical_set(check=False)                                       # needs sage.rings.number_field
[(1 : 1), (-1/2 : 1), (1 : 0)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([3*x^3 - 9/2* x^2*y+y^3, y^3])
f.postcritical_set(check=False)                                       # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
sage: f.postcritical_set()                                                  # needs sage.rings.number_field
[(1 : 1), (4/3 : 1), (1 : 0), (0 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(4)*y**Integer(2), Integer(9)*x**Integer(2) - Integer(12)*x*y])
>>> f.postcritical_set()                                                  # needs sage.rings.number_field
[(1 : 1), (4/3 : 1), (1 : 0), (0 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
f.postcritical_set()                                                  # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(4)*y**Integer(2), Integer(9)*x**Integer(2) - Integer(12)*x*y])
>>> f.postcritical_set()                                                  # needs sage.rings.number_field
[(1 : 1), (4/3 : 1), (1 : 0), (0 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
f.postcritical_set()                                                  # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: K.<v> = QuadraticField(2)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
sage: m = matrix(K, 2, 2, [v, 1, 0, 1])
sage: g = f.conjugate(m)
sage: g.postcritical_set()
[(-3/2*a : 1), (1/2*a : 1), (1 : 0)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('v',)); (v,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + (-Integer(2))*y**Integer(2), y**Integer(2)])
>>> m = matrix(K, Integer(2), Integer(2), [v, Integer(1), Integer(0), Integer(1)])
>>> g = f.conjugate(m)
>>> g.postcritical_set()
[(-3/2*a : 1), (1/2*a : 1), (1 : 0)]

# needs sage.rings.number_field
K.<v> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
m = matrix(K, 2, 2, [v, 1, 0, 1])
g = f.conjugate(m)
g.postcritical_set()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('v',)); (v,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + (-Integer(2))*y**Integer(2), y**Integer(2)])
>>> m = matrix(K, Integer(2), Integer(2), [v, Integer(1), Integer(0), Integer(1)])
>>> g = f.conjugate(m)
>>> g.postcritical_set()
[(-3/2*a : 1), (1/2*a : 1), (1 : 0)]

# needs sage.rings.number_field
K.<v> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
m = matrix(K, 2, 2, [v, 1, 0, 1])
g = f.conjugate(m)
g.postcritical_set()
sage: # needs sage.rings.finite_rings
sage: F.<z> = FiniteField(9)
sage: P.<x,y> = ProjectiveSpace(F, 1)
sage: f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
sage: m = matrix(F, 2, 2, [z, 1, 0, 1])
sage: g = f.conjugate(m)
sage: g.postcritical_set()
[(1 : 0), (0 : 1), (a + 2 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> F = FiniteField(Integer(9), names=('z',)); (z,) = F._first_ngens(1)
>>> P = ProjectiveSpace(F, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + (-Integer(2))*y**Integer(2), y**Integer(2)])
>>> m = matrix(F, Integer(2), Integer(2), [z, Integer(1), Integer(0), Integer(1)])
>>> g = f.conjugate(m)
>>> g.postcritical_set()
[(1 : 0), (0 : 1), (a + 2 : 1)]

# needs sage.rings.finite_rings
F.<z> = FiniteField(9)
P.<x,y> = ProjectiveSpace(F, 1)
f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
m = matrix(F, 2, 2, [z, 1, 0, 1])
g = f.conjugate(m)
g.postcritical_set()
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> F = FiniteField(Integer(9), names=('z',)); (z,) = F._first_ngens(1)
>>> P = ProjectiveSpace(F, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + (-Integer(2))*y**Integer(2), y**Integer(2)])
>>> m = matrix(F, Integer(2), Integer(2), [z, Integer(1), Integer(0), Integer(1)])
>>> g = f.conjugate(m)
>>> g.postcritical_set()
[(1 : 0), (0 : 1), (a + 2 : 1)]

# needs sage.rings.finite_rings
F.<z> = FiniteField(9)
P.<x,y> = ProjectiveSpace(F, 1)
f = DynamicalSystem([x^2 + (-2)*y^2, y^2])
m = matrix(F, 2, 2, [z, 1, 0, 1])
g = f.conjugate(m)
g.postcritical_set()
preperiodic_points(m, n, **kwds)[source]

Compute the preperiodic points of period m, n of this dynamical system defined over the ring R or the base ring of the map.

This is done by finding the rational points on the variety defining the points of period m, n.

For rational maps, where there are potentially infinitely many periodic points of a given period, you must use the return_scheme option. Note that this scheme will include the indeterminacy locus.

INPUT:

  • n – positive integer; the period

  • m – nonnegative integer; the preperiod

kwds:

  • minimal – boolean (default: True); True specifies to find only the preperiodic points of minimal period m,``n`` and False specifies to find all preperiodic points of period m, n

  • formal – boolean (default: False); True specifies to find the formal periodic points only. The formal periodic points are the points in the support of the dynatomic cycle.

  • R – (default: the base ring of the dynamical system) a commutative ring over which to find the preperiodic points

  • return_scheme – boolean (default: False); return a subscheme of the ambient space that defines the m,``n`` th preperiodic points

OUTPUT:

A list of preperiodic points of this map or the subscheme defining the preperiodic points.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQbar, 1)                                   # needs sage.rings.number_field
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])                      # needs sage.rings.number_field
sage: f.preperiodic_points(0, 1)                                            # needs sage.rings.number_field
[(-0.618033988749895? : 1), (1 : 0), (1.618033988749895? : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)# needs sage.rings.number_field
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])                      # needs sage.rings.number_field
>>> f.preperiodic_points(Integer(0), Integer(1))                                            # needs sage.rings.number_field
[(-0.618033988749895? : 1), (1 : 0), (1.618033988749895? : 1)]

P.<x,y> = ProjectiveSpace(QQbar, 1)                                   # needs sage.rings.number_field
f = DynamicalSystem_projective([x^2 - y^2, y^2])                      # needs sage.rings.number_field
f.preperiodic_points(0, 1)                                            # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
sage: f.preperiodic_points(1, 3)                                            # needs sage.rings.function_field
[(-5/4 : 1), (1/4 : 1), (7/4 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(3))                                            # needs sage.rings.function_field
[(-5/4 : 1), (1/4 : 1), (7/4 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.preperiodic_points(1, 3)                                            # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(3))                                            # needs sage.rings.function_field
[(-5/4 : 1), (1/4 : 1), (7/4 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
f.preperiodic_points(1, 3)                                            # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
sage: f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2) , z**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2) , z**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2 , z^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([x^2 - x*y + 2*y^2, x^2 - y^2])
sage: f.preperiodic_points(1, 2, minimal=False)                             # needs sage.rings.function_field
[(-3.133185666641252? : 1),
(-1 : 1),
(-0.3478103847799310? - 1.028852254136693?*I : 1),
(-0.3478103847799310? + 1.028852254136693?*I : 1),
(0.8165928333206258? - 0.6710067557437100?*I : 1),
(0.8165928333206258? + 0.6710067557437100?*I : 1),
(1 : 0),
(1 : 1),
(1.695620769559862? : 1),
(3 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - x*y + Integer(2)*y**Integer(2), x**Integer(2) - y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(2), minimal=False)                             # needs sage.rings.function_field
[(-3.133185666641252? : 1),
(-1 : 1),
(-0.3478103847799310? - 1.028852254136693?*I : 1),
(-0.3478103847799310? + 1.028852254136693?*I : 1),
(0.8165928333206258? - 0.6710067557437100?*I : 1),
(0.8165928333206258? + 0.6710067557437100?*I : 1),
(1 : 0),
(1 : 1),
(1.695620769559862? : 1),
(3 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^2 - x*y + 2*y^2, x^2 - y^2])
f.preperiodic_points(1, 2, minimal=False)                             # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - x*y + Integer(2)*y**Integer(2), x**Integer(2) - y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(2), minimal=False)                             # needs sage.rings.function_field
[(-3.133185666641252? : 1),
(-1 : 1),
(-0.3478103847799310? - 1.028852254136693?*I : 1),
(-0.3478103847799310? + 1.028852254136693?*I : 1),
(0.8165928333206258? - 0.6710067557437100?*I : 1),
(0.8165928333206258? + 0.6710067557437100?*I : 1),
(1 : 0),
(1 : 1),
(1.695620769559862? : 1),
(3 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^2 - x*y + 2*y^2, x^2 - y^2])
f.preperiodic_points(1, 2, minimal=False)                             # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: R.<w> = QQ[]
sage: K.<s> = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sage: sorted(f.preperiodic_points(0, 1), key=str)                           # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['w']; (w,) = R._first_ngens(1)
>>> K = NumberField(w**Integer(6) - Integer(3)*w**Integer(5) + Integer(5)*w**Integer(4) - Integer(5)*w**Integer(3) + Integer(5)*w**Integer(2) - Integer(3)*w + Integer(1), names=('s',)); (s,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + z**Integer(2), y**Integer(2) + x**Integer(2), z**Integer(2) + y**Integer(2)])
>>> sorted(f.preperiodic_points(Integer(0), Integer(1)), key=str)                           # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

# needs sage.rings.number_field
R.<w> = QQ[]
K.<s> = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sorted(f.preperiodic_points(0, 1), key=str)                           # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['w']; (w,) = R._first_ngens(1)
>>> K = NumberField(w**Integer(6) - Integer(3)*w**Integer(5) + Integer(5)*w**Integer(4) - Integer(5)*w**Integer(3) + Integer(5)*w**Integer(2) - Integer(3)*w + Integer(1), names=('s',)); (s,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + z**Integer(2), y**Integer(2) + x**Integer(2), z**Integer(2) + y**Integer(2)])
>>> sorted(f.preperiodic_points(Integer(0), Integer(1)), key=str)                           # needs sage.rings.function_field
[(-2*s^5 + 4*s^4 - 5*s^3 + 3*s^2 - 4*s : -2*s^5 + 5*s^4 - 7*s^3 + 6*s^2 - 7*s + 3 : 1),
 (-s^5 + 3*s^4 - 4*s^3 + 4*s^2 - 4*s + 2 : -s^5 + 2*s^4 - 2*s^3 + s^2 - s : 1),
 (-s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 3*s + 1 : s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 4*s - 1 : 1),
 (1 : 1 : 1),
 (2*s^5 - 6*s^4 + 9*s^3 - 8*s^2 + 7*s - 4 : 2*s^5 - 5*s^4 + 7*s^3 - 5*s^2 + 6*s - 2 : 1),
 (s^5 - 2*s^4 + 2*s^3 + s : s^5 - 3*s^4 + 4*s^3 - 3*s^2 + 2*s - 1 : 1),
 (s^5 - 2*s^4 + 3*s^3 - 3*s^2 + 3*s - 1 : -s^5 + 3*s^4 - 5*s^3 + 4*s^2 - 4*s + 2 : 1)]

# needs sage.rings.number_field
R.<w> = QQ[]
K.<s> = NumberField(w^6 - 3*w^5 + 5*w^4 - 5*w^3 + 5*w^2 - 3*w + 1)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + z^2, y^2 + x^2, z^2 + y^2])
sorted(f.preperiodic_points(0, 1), key=str)                           # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 1/4*y^2, y^2])
sage: f.preperiodic_points(1, 1, formal=True)
[(-1/2 : 1), (1 : 0)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(1)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1), formal=True)
[(-1/2 : 1), (1 : 0)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 1/4*y^2, y^2])
f.preperiodic_points(1, 1, formal=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(1)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1), formal=True)
[(-1/2 : 1), (1 : 0)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 1/4*y^2, y^2])
f.preperiodic_points(1, 1, formal=True)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sage: f.preperiodic_points(0, 2, formal=True)                               # needs sage.libs.pari
[(-1/2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.libs.pari
[(-1/2 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.libs.pari
[(-1/2 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.libs.pari
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: K.<v> = QuadraticField(5)
sage: phi = QQ.embeddings(K)[0]
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.preperiodic_points(1, 1, R=phi)
[(-1/2*v - 1/2 : 1), (1/2*v - 1/2 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> K = QuadraticField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = QQ.embeddings(K)[Integer(0)]
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1), R=phi)
[(-1/2*v - 1/2 : 1), (1/2*v - 1/2 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
K.<v> = QuadraticField(5)
phi = QQ.embeddings(K)[0]
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.preperiodic_points(1, 1, R=phi)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> K = QuadraticField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = QQ.embeddings(K)[Integer(0)]
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1), R=phi)
[(-1/2*v - 1/2 : 1), (1/2*v - 1/2 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
K.<v> = QuadraticField(5)
phi = QQ.embeddings(K)[0]
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.preperiodic_points(1, 1, R=phi)
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: X = P.subscheme(2*x - y)
sage: f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
....:                                domain=X)
sage: f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
[(-1/4 : -1/2 : 1), (1 : 2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*x - y)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(2)*(x**Integer(2) - y**Integer(2)), y**Integer(2) - z**Integer(2)],
...                                domain=X)
>>> f.preperiodic_points(Integer(1), Integer(1))                                            # needs sage.rings.function_field
[(-1/4 : -1/2 : 1), (1 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
X = P.subscheme(2*x - y)
f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
                               domain=X)
f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(Integer(2)*x - y)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(2)*(x**Integer(2) - y**Integer(2)), y**Integer(2) - z**Integer(2)],
...                                domain=X)
>>> f.preperiodic_points(Integer(1), Integer(1))                                            # needs sage.rings.function_field
[(-1/4 : -1/2 : 1), (1 : 2 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
X = P.subscheme(2*x - y)
f = DynamicalSystem_projective([x^2 - y^2, 2*(x^2 - y^2), y^2 - z^2],
                               domain=X)
f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, z^2, y^2])
sage: f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
[(-3/2 : -1 : 1), (-3/2 : 1 : 1), (-1/2 : -1 : 1), (1/2 : -1 : 1),
 (1/2 : 1 : 1), (3/2 : -1 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1))                                            # needs sage.rings.function_field
[(-3/2 : -1 : 1), (-3/2 : 1 : 1), (-1/2 : -1 : 1), (1/2 : -1 : 1),
 (1/2 : 1 : 1), (3/2 : -1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, z^2, y^2])
f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(1))                                            # needs sage.rings.function_field
[(-3/2 : -1 : 1), (-3/2 : 1 : 1), (-1/2 : -1 : 1), (1/2 : -1 : 1),
 (1/2 : 1 : 1), (3/2 : -1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, z^2, y^2])
f.preperiodic_points(1, 1)                                            # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(GF(5), 2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2])
sage: sorted(f.preperiodic_points(2, 1))                                    # needs sage.rings.function_field
[(0 : 2 : 1), (0 : 3 : 1), (1 : 2 : 1), (1 : 3 : 1), (2 : 0 : 1), (2 : 1 : 0),
 (2 : 1 : 1), (2 : 2 : 1), (2 : 3 : 1), (2 : 4 : 1), (3 : 0 : 1), (3 : 1 : 0),
 (3 : 1 : 1), (3 : 2 : 1), (3 : 3 : 1), (3 : 4 : 1), (4 : 2 : 1), (4 : 3 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> sorted(f.preperiodic_points(Integer(2), Integer(1)))                                    # needs sage.rings.function_field
[(0 : 2 : 1), (0 : 3 : 1), (1 : 2 : 1), (1 : 3 : 1), (2 : 0 : 1), (2 : 1 : 0),
 (2 : 1 : 1), (2 : 2 : 1), (2 : 3 : 1), (2 : 4 : 1), (3 : 0 : 1), (3 : 1 : 0),
 (3 : 1 : 1), (3 : 2 : 1), (3 : 3 : 1), (3 : 4 : 1), (4 : 2 : 1), (4 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
sorted(f.preperiodic_points(2, 1))                                    # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> sorted(f.preperiodic_points(Integer(2), Integer(1)))                                    # needs sage.rings.function_field
[(0 : 2 : 1), (0 : 3 : 1), (1 : 2 : 1), (1 : 3 : 1), (2 : 0 : 1), (2 : 1 : 0),
 (2 : 1 : 1), (2 : 2 : 1), (2 : 3 : 1), (2 : 4 : 1), (3 : 0 : 1), (3 : 1 : 0),
 (3 : 1 : 1), (3 : 2 : 1), (3 : 3 : 1), (3 : 4 : 1), (4 : 2 : 1), (4 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
sorted(f.preperiodic_points(2, 1))                                    # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(GF(5), 2)
sage: f = DynamicalSystem_projective([x^2, x*y, z^2])
sage: f.preperiodic_points(2, 1, return_scheme=True, minimal=False)
Closed subscheme of
 Projective Space of dimension 2 over Finite Field of size 5 defined by:
  0,
  x^8*z^4 - x^4*z^8,
  x^7*y*z^4 - x^3*y*z^8

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y, z**Integer(2)])
>>> f.preperiodic_points(Integer(2), Integer(1), return_scheme=True, minimal=False)
Closed subscheme of
 Projective Space of dimension 2 over Finite Field of size 5 defined by:
  0,
  x^8*z^4 - x^4*z^8,
  x^7*y*z^4 - x^3*y*z^8

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^2, x*y, z^2])
f.preperiodic_points(2, 1, return_scheme=True, minimal=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), x*y, z**Integer(2)])
>>> f.preperiodic_points(Integer(2), Integer(1), return_scheme=True, minimal=False)
Closed subscheme of
 Projective Space of dimension 2 over Finite Field of size 5 defined by:
  0,
  x^8*z^4 - x^4*z^8,
  x^7*y*z^4 - x^3*y*z^8

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^2, x*y, z^2])
f.preperiodic_points(2, 1, return_scheme=True, minimal=False)

When the ring over which to find the preperiodic points is a number field, the ordering of the preperiodic points might depend on the architecture (32 or 64 bits):

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: R.<z> = QQ[]
sage: K.<v> = NumberField(z^4 - z^2 - 1)                                    # needs sage.rings.number_field
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: sorted(f.preperiodic_points(2, 1, R=K), key=str)                      # needs sage.rings.number_field
[(-v : 1), (v : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(4) - z**Integer(2) - Integer(1), names=('v',)); (v,) = K._first_ngens(1)# needs sage.rings.number_field
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> sorted(f.preperiodic_points(Integer(2), Integer(1), R=K), key=str)                      # needs sage.rings.number_field
[(-v : 1), (v : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
R.<z> = QQ[]
K.<v> = NumberField(z^4 - z^2 - 1)                                    # needs sage.rings.number_field
f = DynamicalSystem_projective([x^2 - y^2, y^2])
sorted(f.preperiodic_points(2, 1, R=K), key=str)                      # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2, z^2])
sage: f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2, z^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.preperiodic_points(Integer(0), Integer(2), formal=True)                               # needs sage.rings.function_field
[(-1/2 : 1 : 0), (-1/2 : 1 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2, z^2])
f.preperiodic_points(0, 2, formal=True)                               # needs sage.rings.function_field
sage: S.<c> = QQ[]
sage: R.<x,y> = PolynomialRing(S, 2)
sage: P = ProjectiveSpace(R)
sage: f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
sage: f.preperiodic_points(1, 2, return_scheme=True)                        # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
 Polynomial Ring in c over Rational Field defined by:
  x^2 - x*y + (c + 1)*y^2

>>> from sage.all import *
>>> S = QQ['c']; (c,) = S._first_ngens(1)
>>> R = PolynomialRing(S, Integer(2), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(2), return_scheme=True)                        # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
 Polynomial Ring in c over Rational Field defined by:
  x^2 - x*y + (c + 1)*y^2

S.<c> = QQ[]
R.<x,y> = PolynomialRing(S, 2)
P = ProjectiveSpace(R)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.preperiodic_points(1, 2, return_scheme=True)                        # needs sage.rings.function_field
>>> from sage.all import *
>>> S = QQ['c']; (c,) = S._first_ngens(1)
>>> R = PolynomialRing(S, Integer(2), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.preperiodic_points(Integer(1), Integer(2), return_scheme=True)                        # needs sage.rings.function_field
Closed subscheme of Projective Space of dimension 1 over Univariate
 Polynomial Ring in c over Rational Field defined by:
  x^2 - x*y + (c + 1)*y^2

S.<c> = QQ[]
R.<x,y> = PolynomialRing(S, 2)
P = ProjectiveSpace(R)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.preperiodic_points(1, 2, return_scheme=True)                        # needs sage.rings.function_field
primes_of_bad_reduction(check=True)[source]

Determine the primes of bad reduction for this dynamical system.

Must be defined over a number field.

If check is True, each prime is verified to be of bad reduction.

ALGORITHM:

\(p\) is a prime of bad reduction if and only if the defining polynomials of self have a common zero. Or stated another way, \(p\) is a prime of bad reduction if and only if the radical of the ideal defined by the defining polynomials of self is not \((x_0,x_1,\ldots,x_N)\). This happens if and only if some power of each \(x_i\) is not in the ideal defined by the defining polynomials of self. This last condition is what is checked. The lcm of the coefficients of the monomials \(x_i\) in a Groebner basis is computed. This may return extra primes.

INPUT:

  • check – boolean (default: True)

OUTPUT: list of primes

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([1/3*x^2 + 1/2*y^2, y^2])
sage: f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[2, 3]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1)/Integer(3)*x**Integer(2) + Integer(1)/Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[2, 3]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([1/3*x^2 + 1/2*y^2, y^2])
f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
sage: P.<x,y,z,w> = ProjectiveSpace(QQ,3)
sage: f = DynamicalSystem_projective([12*x*z - 7*y^2, 31*x^2 - y^2,
....:                                 26*z^2, 3*w^2 - z*w])
sage: f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[2, 3, 7, 13, 31]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([Integer(12)*x*z - Integer(7)*y**Integer(2), Integer(31)*x**Integer(2) - y**Integer(2),
...                                 Integer(26)*z**Integer(2), Integer(3)*w**Integer(2) - z*w])
>>> f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[2, 3, 7, 13, 31]

P.<x,y,z,w> = ProjectiveSpace(QQ,3)
f = DynamicalSystem_projective([12*x*z - 7*y^2, 31*x^2 - y^2,
                                26*z^2, 3*w^2 - z*w])
f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([Integer(12)*x*z - Integer(7)*y**Integer(2), Integer(31)*x**Integer(2) - y**Integer(2),
...                                 Integer(26)*z**Integer(2), Integer(3)*w**Integer(2) - z*w])
>>> f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[2, 3, 7, 13, 31]

P.<x,y,z,w> = ProjectiveSpace(QQ,3)
f = DynamicalSystem_projective([12*x*z - 7*y^2, 31*x^2 - y^2,
                                26*z^2, 3*w^2 - z*w])
f.primes_of_bad_reduction()                                           # needs sage.rings.function_field

A number field example:

sage: # needs sage.rings.number_field
sage: R.<z> = QQ[]
sage: K.<a> = NumberField(z^2 - 2)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([1/3*x^2+1/a*y^2, y^2])
sage: f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[Fractional ideal (a), Fractional ideal (3)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['z']; (z,) = R._first_ngens(1)
>>> K = NumberField(z**Integer(2) - Integer(2), names=('a',)); (a,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(1)/Integer(3)*x**Integer(2)+Integer(1)/a*y**Integer(2), y**Integer(2)])
>>> f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[Fractional ideal (a), Fractional ideal (3)]

# needs sage.rings.number_field
R.<z> = QQ[]
K.<a> = NumberField(z^2 - 2)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([1/3*x^2+1/a*y^2, y^2])
f.primes_of_bad_reduction()                                           # needs sage.rings.function_field

This is an example where check=False returns extra primes:

sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: f = DynamicalSystem_projective([3*x*y^2 + 7*y^3 - 4*y^2*z + 5*z^3,
....:                                 -5*x^3 + x^2*y + y^3 + 2*x^2*z,
....:                                 -2*x^2*y + x*y^2 + y^3 - 4*y^2*z + x*z^2])
sage: f.primes_of_bad_reduction(False)                                      # needs sage.rings.function_field
[2, 5, 37, 2239, 304432717]
sage: f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[5, 37, 2239, 304432717]

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(3)*x*y**Integer(2) + Integer(7)*y**Integer(3) - Integer(4)*y**Integer(2)*z + Integer(5)*z**Integer(3),
...                                 -Integer(5)*x**Integer(3) + x**Integer(2)*y + y**Integer(3) + Integer(2)*x**Integer(2)*z,
...                                 -Integer(2)*x**Integer(2)*y + x*y**Integer(2) + y**Integer(3) - Integer(4)*y**Integer(2)*z + x*z**Integer(2)])
>>> f.primes_of_bad_reduction(False)                                      # needs sage.rings.function_field
[2, 5, 37, 2239, 304432717]
>>> f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
[5, 37, 2239, 304432717]

P.<x,y,z> = ProjectiveSpace(ZZ,2)
f = DynamicalSystem_projective([3*x*y^2 + 7*y^3 - 4*y^2*z + 5*z^3,
                                -5*x^3 + x^2*y + y^3 + 2*x^2*z,
                                -2*x^2*y + x*y^2 + y^3 - 4*y^2*z + x*z^2])
f.primes_of_bad_reduction(False)                                      # needs sage.rings.function_field
f.primes_of_bad_reduction()                                           # needs sage.rings.function_field
ramification_type(R=None, stable=True)[source]

Return the ramification type of endomorphisms of \(\mathbb{P}^1\).

Only branch points defined over the ring R contribute to the ramification type if specified, otherwise R is the ring of definition for self.

Note that branch points defined over R may not be geometric points if stable not set to True.

If R is specified, stable is ignored.

If stable, then this will return the ramification type over an extension which splits the Galois orbits of critical points.

INPUT:

  • R – ring or morphism (optional)

  • split – boolean (optional)

OUTPUT:

list of lists, each term being the list of ramification indices in the pre-images of one critical value

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^4, y^4])
sage: F.ramification_type()                                                 # needs sage.rings.number_field
[[4], [4]]

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([x^3, 4*y^3 - 3*x^2*y])
sage: F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2], [3]]

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([(x + y)^4, 16*x*y*(x-y)^2])
sage: F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2, 2], [4]]

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([(x + y)*(x - y)^3, y*(2*x+y)^3])
sage: F.ramification_type()                                                 # needs sage.rings.number_field
[[3], [3], [3]]

sage: F = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
sage: F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2], [3]]
sage: F.ramification_type(R=F.base_ring())                                  # needs sage.rings.function_field
[[2], [3]]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(4), y**Integer(4)])
>>> F.ramification_type()                                                 # needs sage.rings.number_field
[[4], [4]]

>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([x**Integer(3), Integer(4)*y**Integer(3) - Integer(3)*x**Integer(2)*y])
>>> F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2], [3]]

>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)**Integer(4), Integer(16)*x*y*(x-y)**Integer(2)])
>>> F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2, 2], [4]]

>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> F = DynamicalSystem_projective([(x + y)*(x - y)**Integer(3), y*(Integer(2)*x+y)**Integer(3)])
>>> F.ramification_type()                                                 # needs sage.rings.number_field
[[3], [3], [3]]

>>> F = DynamicalSystem_projective([x**Integer(3) - Integer(2)*x*y**Integer(2) + Integer(2)*y**Integer(3), y**Integer(3)])
>>> F.ramification_type()                                                 # needs sage.rings.number_field
[[2], [2], [3]]
>>> F.ramification_type(R=F.base_ring())                                  # needs sage.rings.function_field
[[2], [3]]

P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^4, y^4])
F.ramification_type()                                                 # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([x^3, 4*y^3 - 3*x^2*y])
F.ramification_type()                                                 # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)^4, 16*x*y*(x-y)^2])
F.ramification_type()                                                 # needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([(x + y)*(x - y)^3, y*(2*x+y)^3])
F.ramification_type()                                                 # needs sage.rings.number_field
F = DynamicalSystem_projective([x^3 - 2*x*y^2 + 2*y^3, y^3])
F.ramification_type()                                                 # needs sage.rings.number_field
F.ramification_type(R=F.base_ring())                                  # needs sage.rings.function_field
reduced_form(**kwds)[source]

Return reduced form of this dynamical system.

The reduced form is the \(SL(2, \ZZ)\) equivalent morphism obtained by applying the binary form reduction algorithm from Stoll and Cremona [CS2003] to the homogeneous polynomial defining the periodic points (the dynatomic polynomial). The smallest period \(n\) with enough periodic points is used and without roots of too large multiplicity.

This should also minimize the size of the coefficients, but this is not always the case. By default the coefficient minimizing algorithm in [HS2018] is applied.

See sage.rings.polynomial.multi_polynomial.reduced_form() for the information on binary form reduction.

Implemented by Rebecca Lauren Miller as part of GSOC 2016. Minimal height added by Ben Hutz July 2018.

INPUT: keyword arguments:

  • prec – integer (default: 300); desired precision

  • return_conjuagtion – boolean (default: True); return an element of \(SL(2, \ZZ)\)

  • error_limit – (default: 0.000001) a real number, sets the error tolerance

  • smallest_coeffs – boolean (default: True); whether to find the model with smallest coefficients

  • dynatomic – boolean (default: True); to use formal periodic points

  • start_n – positive integer (default: 1); first period to try to find appropriate binary form

  • emb – (optional) embedding of based field into CC

  • algorithm – (optional) which algorithm to use to find all minimal models. Can be one of the following:

    • 'BM' – Bruin-Molnar algorithm [BM2012]

    • 'HS' – Hutz-Stoll algorithm [HS2018]

  • check_minimal – boolean (default: True); whether to check if this map is a minimal model

  • smallest_coeffs – boolean (default: True); whether to find the model with smallest coefficients

OUTPUT:

  • a projective morphism

  • a matrix

EXAMPLES:

sage: PS.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^3 + x*y^2, y^3])
sage: m = matrix(QQ, 2, 2, [-201221, -1, 1, 0])
sage: f = f.conjugate(m)
sage: f.reduced_form(prec=50, smallest_coeffs=False)  # this needs 2 periodic
Traceback (most recent call last):
...
ValueError: accuracy of Newton's root not within tolerance(0.00006... > 1e-06), increase precision
sage: f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to (x^3 + x*y^2 : y^3)
,

[     0     -1]
[     1 201221]
)

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + x*y**Integer(2), y**Integer(3)])
>>> m = matrix(QQ, Integer(2), Integer(2), [-Integer(201221), -Integer(1), Integer(1), Integer(0)])
>>> f = f.conjugate(m)
>>> f.reduced_form(prec=Integer(50), smallest_coeffs=False)  # this needs 2 periodic
Traceback (most recent call last):
...
ValueError: accuracy of Newton's root not within tolerance(0.00006... > 1e-06), increase precision
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to (x^3 + x*y^2 : y^3)
,
<BLANKLINE>
[     0     -1]
[     1 201221]
)

PS.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^3 + x*y^2, y^3])
m = matrix(QQ, 2, 2, [-201221, -1, 1, 0])
f = f.conjugate(m)
f.reduced_form(prec=50, smallest_coeffs=False)  # this needs 2 periodic
f.reduced_form(smallest_coeffs=False)
sage: PS.<x,y> = ProjectiveSpace(ZZ, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y, y^2])  # this needs 3 periodic
sage: m = matrix(QQ, 2, 2, [-221, -1, 1, 0])
sage: f = f.conjugate(m)
sage: f.reduced_form(prec=200, smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to (-x^2 + x*y - y^2 : -y^2)
,
[  0  -1]
[  1 220]
)

>>> from sage.all import *
>>> PS = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])  # this needs 3 periodic
>>> m = matrix(QQ, Integer(2), Integer(2), [-Integer(221), -Integer(1), Integer(1), Integer(0)])
>>> f = f.conjugate(m)
>>> f.reduced_form(prec=Integer(200), smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to (-x^2 + x*y - y^2 : -y^2)
,
[  0  -1]
[  1 220]
)

PS.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])  # this needs 3 periodic
m = matrix(QQ, 2, 2, [-221, -1, 1, 0])
f = f.conjugate(m)
f.reduced_form(prec=200, smallest_coeffs=False)
>>> from sage.all import *
>>> PS = ProjectiveSpace(ZZ, Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])  # this needs 3 periodic
>>> m = matrix(QQ, Integer(2), Integer(2), [-Integer(221), -Integer(1), Integer(1), Integer(0)])
>>> f = f.conjugate(m)
>>> f.reduced_form(prec=Integer(200), smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Integer Ring
  Defn: Defined on coordinates by sending (x : y) to (-x^2 + x*y - y^2 : -y^2)
,
[  0  -1]
[  1 220]
)

PS.<x,y> = ProjectiveSpace(ZZ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])  # this needs 3 periodic
m = matrix(QQ, 2, 2, [-221, -1, 1, 0])
f = f.conjugate(m)
f.reduced_form(prec=200, smallest_coeffs=False)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^3, y^3])
sage: f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to (x^3 : y^3)
,

[1 0]
[0 1]
)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to (x^3 : y^3)
,
<BLANKLINE>
[1 0]
[0 1]
)

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^3, y^3])
f.reduced_form(smallest_coeffs=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to (x^3 : y^3)
,
<BLANKLINE>
[1 0]
[0 1]
)

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^3, y^3])
f.reduced_form(smallest_coeffs=False)
sage: PS.<X,Y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([7365*X^4 + 12564*X^3*Y + 8046*X^2*Y^2
....:                                   + 2292*X*Y^3 + 245*Y^4,
....:                                 -12329*X^4 - 21012*X^3*Y - 13446*X^2*Y^2
....:                                   - 3828*X*Y^3 - 409*Y^4])
sage: f.reduced_form(prec=30, smallest_coeffs=False)
Traceback (most recent call last):
...
ValueError: accuracy of Newton's root not within tolerance(0.00008... > 1e-06), increase precision
sage: f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (-7*X^4 - 12*X^3*Y - 42*X^2*Y^2 - 12*X*Y^3 - 7*Y^4
         : -X^4 - 4*X^3*Y - 6*X^2*Y^2 - 4*X*Y^3 - Y^4),

[-1  2]
[ 2 -5]
)

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7365)*X**Integer(4) + Integer(12564)*X**Integer(3)*Y + Integer(8046)*X**Integer(2)*Y**Integer(2)
...                                   + Integer(2292)*X*Y**Integer(3) + Integer(245)*Y**Integer(4),
...                                 -Integer(12329)*X**Integer(4) - Integer(21012)*X**Integer(3)*Y - Integer(13446)*X**Integer(2)*Y**Integer(2)
...                                   - Integer(3828)*X*Y**Integer(3) - Integer(409)*Y**Integer(4)])
>>> f.reduced_form(prec=Integer(30), smallest_coeffs=False)
Traceback (most recent call last):
...
ValueError: accuracy of Newton's root not within tolerance(0.00008... > 1e-06), increase precision
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (-7*X^4 - 12*X^3*Y - 42*X^2*Y^2 - 12*X*Y^3 - 7*Y^4
         : -X^4 - 4*X^3*Y - 6*X^2*Y^2 - 4*X*Y^3 - Y^4),
<BLANKLINE>
[-1  2]
[ 2 -5]
)

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7365*X^4 + 12564*X^3*Y + 8046*X^2*Y^2
                                  + 2292*X*Y^3 + 245*Y^4,
                                -12329*X^4 - 21012*X^3*Y - 13446*X^2*Y^2
                                  - 3828*X*Y^3 - 409*Y^4])
f.reduced_form(prec=30, smallest_coeffs=False)
f.reduced_form(smallest_coeffs=False)
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ,Integer(1), names=('X', 'Y',)); (X, Y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7365)*X**Integer(4) + Integer(12564)*X**Integer(3)*Y + Integer(8046)*X**Integer(2)*Y**Integer(2)
...                                   + Integer(2292)*X*Y**Integer(3) + Integer(245)*Y**Integer(4),
...                                 -Integer(12329)*X**Integer(4) - Integer(21012)*X**Integer(3)*Y - Integer(13446)*X**Integer(2)*Y**Integer(2)
...                                   - Integer(3828)*X*Y**Integer(3) - Integer(409)*Y**Integer(4)])
>>> f.reduced_form(prec=Integer(30), smallest_coeffs=False)
Traceback (most recent call last):
...
ValueError: accuracy of Newton's root not within tolerance(0.00008... > 1e-06), increase precision
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (X : Y) to
        (-7*X^4 - 12*X^3*Y - 42*X^2*Y^2 - 12*X*Y^3 - 7*Y^4
         : -X^4 - 4*X^3*Y - 6*X^2*Y^2 - 4*X*Y^3 - Y^4),
<BLANKLINE>
[-1  2]
[ 2 -5]
)

PS.<X,Y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([7365*X^4 + 12564*X^3*Y + 8046*X^2*Y^2
                                  + 2292*X*Y^3 + 245*Y^4,
                                -12329*X^4 - 21012*X^3*Y - 13446*X^2*Y^2
                                  - 3828*X*Y^3 - 409*Y^4])
f.reduced_form(prec=30, smallest_coeffs=False)
f.reduced_form(smallest_coeffs=False)
sage: # needs sage.rings.real_mpfr sage.symbolic
sage: P.<x,y> = ProjectiveSpace(RR, 1)
sage: f = DynamicalSystem_projective([x^4, RR(sqrt(2))*y^4])
sage: m = matrix(RR, 2, 2, [1,12,0,1])
sage: f = f.conjugate(m)
sage: g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

>>> from sage.all import *
>>> # needs sage.rings.real_mpfr sage.symbolic
>>> P = ProjectiveSpace(RR, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4), RR(sqrt(Integer(2)))*y**Integer(4)])
>>> m = matrix(RR, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

# needs sage.rings.real_mpfr sage.symbolic
P.<x,y> = ProjectiveSpace(RR, 1)
f = DynamicalSystem_projective([x^4, RR(sqrt(2))*y^4])
m = matrix(RR, 2, 2, [1,12,0,1])
f = f.conjugate(m)
g, m = f.reduced_form(smallest_coeffs=False); m
>>> from sage.all import *
>>> # needs sage.rings.real_mpfr sage.symbolic
>>> P = ProjectiveSpace(RR, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4), RR(sqrt(Integer(2)))*y**Integer(4)])
>>> m = matrix(RR, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

# needs sage.rings.real_mpfr sage.symbolic
P.<x,y> = ProjectiveSpace(RR, 1)
f = DynamicalSystem_projective([x^4, RR(sqrt(2))*y^4])
m = matrix(RR, 2, 2, [1,12,0,1])
f = f.conjugate(m)
g, m = f.reduced_form(smallest_coeffs=False); m
sage: # needs sage.rings.real_mpfr sage.symbolic
sage: P.<x,y> = ProjectiveSpace(CC, 1)
sage: f = DynamicalSystem_projective([x^4, CC(sqrt(-2))*y^4])
sage: m = matrix(CC, 2, 2, [1,12,0,1])
sage: f = f.conjugate(m)
sage: g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

>>> from sage.all import *
>>> # needs sage.rings.real_mpfr sage.symbolic
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4), CC(sqrt(-Integer(2)))*y**Integer(4)])
>>> m = matrix(CC, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

# needs sage.rings.real_mpfr sage.symbolic
P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^4, CC(sqrt(-2))*y^4])
m = matrix(CC, 2, 2, [1,12,0,1])
f = f.conjugate(m)
g, m = f.reduced_form(smallest_coeffs=False); m
>>> from sage.all import *
>>> # needs sage.rings.real_mpfr sage.symbolic
>>> P = ProjectiveSpace(CC, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4), CC(sqrt(-Integer(2)))*y**Integer(4)])
>>> m = matrix(CC, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> g, m = f.reduced_form(smallest_coeffs=False); m
[  1 -12]
[  0   1]

# needs sage.rings.real_mpfr sage.symbolic
P.<x,y> = ProjectiveSpace(CC, 1)
f = DynamicalSystem_projective([x^4, CC(sqrt(-2))*y^4])
m = matrix(CC, 2, 2, [1,12,0,1])
f = f.conjugate(m)
g, m = f.reduced_form(smallest_coeffs=False); m
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(2)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^3, w*y^3])
sage: m = matrix(K, 2, 2, [1,12,0,1])
sage: f = f.conjugate(m)
sage: f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^2 - 2 with w = 1.414213562373095?
  Defn: Defined on coordinates by sending (x : y) to (x^3 : w*y^3) ,

[  1 -12]
[  0   1]
)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), w*y**Integer(3)])
>>> m = matrix(K, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^2 - 2 with w = 1.414213562373095?
  Defn: Defined on coordinates by sending (x : y) to (x^3 : w*y^3) ,
<BLANKLINE>
[  1 -12]
[  0   1]
)

# needs sage.rings.number_field
K.<w> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^3, w*y^3])
m = matrix(K, 2, 2, [1,12,0,1])
f = f.conjugate(m)
f.reduced_form(smallest_coeffs=False)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(2), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), w*y**Integer(3)])
>>> m = matrix(K, Integer(2), Integer(2), [Integer(1),Integer(12),Integer(0),Integer(1)])
>>> f = f.conjugate(m)
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^2 - 2 with w = 1.414213562373095?
  Defn: Defined on coordinates by sending (x : y) to (x^3 : w*y^3) ,
<BLANKLINE>
[  1 -12]
[  0   1]
)

# needs sage.rings.number_field
K.<w> = QuadraticField(2)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^3, w*y^3])
m = matrix(K, 2, 2, [1,12,0,1])
f = f.conjugate(m)
f.reduced_form(smallest_coeffs=False)
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = NumberField(x^5 + x - 3,
....:                     embedding=(x^5 + x - 3).roots(ring=CC)[0][0])
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([12*x^3, 2334*w*y^3])
sage: m = matrix(K, 2, 2, [-12,1,1,0])
sage: f = f.conjugate(m)
sage: f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^5 + x - 3 with w = 1.132997565885066?
  Defn: Defined on coordinates by sending (x : y) to
        (12*x^3 : (2334*w)*y^3) ,

[  0  -1]
[  1 -12]
)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(5) + x - Integer(3),
...                     embedding=(x**Integer(5) + x - Integer(3)).roots(ring=CC)[Integer(0)][Integer(0)], names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(12)*x**Integer(3), Integer(2334)*w*y**Integer(3)])
>>> m = matrix(K, Integer(2), Integer(2), [-Integer(12),Integer(1),Integer(1),Integer(0)])
>>> f = f.conjugate(m)
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^5 + x - 3 with w = 1.132997565885066?
  Defn: Defined on coordinates by sending (x : y) to
        (12*x^3 : (2334*w)*y^3) ,
<BLANKLINE>
[  0  -1]
[  1 -12]
)

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^5 + x - 3,
                    embedding=(x^5 + x - 3).roots(ring=CC)[0][0])
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([12*x^3, 2334*w*y^3])
m = matrix(K, 2, 2, [-12,1,1,0])
f = f.conjugate(m)
f.reduced_form(smallest_coeffs=False)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(5) + x - Integer(3),
...                     embedding=(x**Integer(5) + x - Integer(3)).roots(ring=CC)[Integer(0)][Integer(0)], names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(12)*x**Integer(3), Integer(2334)*w*y**Integer(3)])
>>> m = matrix(K, Integer(2), Integer(2), [-Integer(12),Integer(1),Integer(1),Integer(0)])
>>> f = f.conjugate(m)
>>> f.reduced_form(smallest_coeffs=False)
(
Dynamical System of Projective Space of dimension 1 over Number Field in w
 with defining polynomial x^5 + x - 3 with w = 1.132997565885066?
  Defn: Defined on coordinates by sending (x : y) to
        (12*x^3 : (2334*w)*y^3) ,
<BLANKLINE>
[  0  -1]
[  1 -12]
)

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^5 + x - 3,
                    embedding=(x^5 + x - 3).roots(ring=CC)[0][0])
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([12*x^3, 2334*w*y^3])
m = matrix(K, 2, 2, [-12,1,1,0])
f = f.conjugate(m)
f.reduced_form(smallest_coeffs=False)
sage: P.<x,y> = QQ[]
sage: f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
sage: f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 - 2*y^2 : -x^2 - 2*y^2)
,

[ 2 -2]
[ 3  0]
)

>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(4)*y**Integer(2), Integer(9)*x**Integer(2) - Integer(12)*x*y])
>>> f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 - 2*y^2 : -x^2 - 2*y^2)
,
<BLANKLINE>
[ 2 -2]
[ 3  0]
)

P.<x,y> = QQ[]
f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
f.reduced_form()
>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(4)*y**Integer(2), Integer(9)*x**Integer(2) - Integer(12)*x*y])
>>> f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (2*x^2 - 2*y^2 : -x^2 - 2*y^2)
,
<BLANKLINE>
[ 2 -2]
[ 3  0]
)

P.<x,y> = QQ[]
f = DynamicalSystem([-4*y^2, 9*x^2 - 12*x*y])
f.reduced_form()
sage: P.<x,y> = QQ[]
sage: f = DynamicalSystem([-2*x^3 - 9*x^2*y - 12*x*y^2 - 6*y^3 , y^3])
sage: f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + 3*x^2*y : 3*x*y^2 + y^3)
,

[-1 -2]
[ 1  1]
)

>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(2)*x**Integer(3) - Integer(9)*x**Integer(2)*y - Integer(12)*x*y**Integer(2) - Integer(6)*y**Integer(3) , y**Integer(3)])
>>> f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + 3*x^2*y : 3*x*y^2 + y^3)
,
<BLANKLINE>
[-1 -2]
[ 1  1]
)

P.<x,y> = QQ[]
f = DynamicalSystem([-2*x^3 - 9*x^2*y - 12*x*y^2 - 6*y^3 , y^3])
f.reduced_form()
>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([-Integer(2)*x**Integer(3) - Integer(9)*x**Integer(2)*y - Integer(12)*x*y**Integer(2) - Integer(6)*y**Integer(3) , y**Integer(3)])
>>> f.reduced_form()
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + 3*x^2*y : 3*x*y^2 + y^3)
,
<BLANKLINE>
[-1 -2]
[ 1  1]
)

P.<x,y> = QQ[]
f = DynamicalSystem([-2*x^3 - 9*x^2*y - 12*x*y^2 - 6*y^3 , y^3])
f.reduced_form()
sage: P.<x,y> = QQ[]
sage: f = DynamicalSystem([4*x^2 - 7*y^2, 4*y^2])
sage: f.reduced_form(start_n=2, dynatomic=False) #long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y - y^2 : y^2)
,

[ 2 -1]
[ 0  2]
)

>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(4)*x**Integer(2) - Integer(7)*y**Integer(2), Integer(4)*y**Integer(2)])
>>> f.reduced_form(start_n=Integer(2), dynatomic=False) #long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y - y^2 : y^2)
,
<BLANKLINE>
[ 2 -1]
[ 0  2]
)

P.<x,y> = QQ[]
f = DynamicalSystem([4*x^2 - 7*y^2, 4*y^2])
f.reduced_form(start_n=2, dynatomic=False) #long time
>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(4)*x**Integer(2) - Integer(7)*y**Integer(2), Integer(4)*y**Integer(2)])
>>> f.reduced_form(start_n=Integer(2), dynatomic=False) #long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y - y^2 : y^2)
,
<BLANKLINE>
[ 2 -1]
[ 0  2]
)

P.<x,y> = QQ[]
f = DynamicalSystem([4*x^2 - 7*y^2, 4*y^2])
f.reduced_form(start_n=2, dynatomic=False) #long time
sage: P.<x,y> = QQ[]
sage: f = DynamicalSystem([4*x^2 + y^2, 4*y^2])
sage: f.reduced_form()  # long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y + y^2 : y^2)
,

[ 2 -1]
[ 0  2]
)

>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(4)*x**Integer(2) + y**Integer(2), Integer(4)*y**Integer(2)])
>>> f.reduced_form()  # long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y + y^2 : y^2)
,
<BLANKLINE>
[ 2 -1]
[ 0  2]
)

P.<x,y> = QQ[]
f = DynamicalSystem([4*x^2 + y^2, 4*y^2])
f.reduced_form()  # long time
>>> from sage.all import *
>>> P = QQ['x, y']; (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([Integer(4)*x**Integer(2) + y**Integer(2), Integer(4)*y**Integer(2)])
>>> f.reduced_form()  # long time
(
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (x^2 - x*y + y^2 : y^2)
,
<BLANKLINE>
[ 2 -1]
[ 0  2]
)

P.<x,y> = QQ[]
f = DynamicalSystem([4*x^2 + y^2, 4*y^2])
f.reduced_form()  # long time
resultant(normalize=False)[source]

Compute the resultant of the defining polynomials of this dynamical system.

If normalize is True, then first normalize the coordinate functions with normalize_coordinates().

INPUT:

  • normalize – boolean (default: False)

OUTPUT: an element of the base ring of this map

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 6*y^2])
sage: f.resultant()                                                         # needs sage.libs.pari
36

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(6)*y**Integer(2)])
>>> f.resultant()                                                         # needs sage.libs.pari
36

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, 6*y^2])
f.resultant()                                                         # needs sage.libs.pari
sage: R.<t> = PolynomialRing(GF(17))
sage: P.<x,y> = ProjectiveSpace(R,1)
sage: f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2])
sage: f.resultant()                                                         # needs sage.libs.pari
2*t^2

>>> from sage.all import *
>>> R = PolynomialRing(GF(Integer(17)), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([t*x**Integer(2) + t*y**Integer(2), Integer(6)*y**Integer(2)])
>>> f.resultant()                                                         # needs sage.libs.pari
2*t^2

R.<t> = PolynomialRing(GF(17))
P.<x,y> = ProjectiveSpace(R,1)
f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2])
f.resultant()                                                         # needs sage.libs.pari
>>> from sage.all import *
>>> R = PolynomialRing(GF(Integer(17)), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([t*x**Integer(2) + t*y**Integer(2), Integer(6)*y**Integer(2)])
>>> f.resultant()                                                         # needs sage.libs.pari
2*t^2

R.<t> = PolynomialRing(GF(17))
P.<x,y> = ProjectiveSpace(R,1)
f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2])
f.resultant()                                                         # needs sage.libs.pari
sage: R.<t> = PolynomialRing(GF(17))
sage: P.<x,y,z> = ProjectiveSpace(R,2)
sage: f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2, 2*t*z^2])
sage: f.resultant()
13*t^8

>>> from sage.all import *
>>> R = PolynomialRing(GF(Integer(17)), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([t*x**Integer(2) + t*y**Integer(2), Integer(6)*y**Integer(2), Integer(2)*t*z**Integer(2)])
>>> f.resultant()
13*t^8

R.<t> = PolynomialRing(GF(17))
P.<x,y,z> = ProjectiveSpace(R,2)
f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2, 2*t*z^2])
f.resultant()
>>> from sage.all import *
>>> R = PolynomialRing(GF(Integer(17)), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([t*x**Integer(2) + t*y**Integer(2), Integer(6)*y**Integer(2), Integer(2)*t*z**Integer(2)])
>>> f.resultant()
13*t^8

R.<t> = PolynomialRing(GF(17))
P.<x,y,z> = ProjectiveSpace(R,2)
f = DynamicalSystem_projective([t*x^2 + t*y^2, 6*y^2, 2*t*z^2])
f.resultant()
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: F = DynamicalSystem_projective([x^2 + y^2, 6*y^2, 10*x*z + z^2 + y^2])
sage: F.resultant()
1296

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(6)*y**Integer(2), Integer(10)*x*z + z**Integer(2) + y**Integer(2)])
>>> F.resultant()
1296

P.<x,y,z> = ProjectiveSpace(QQ,2)
F = DynamicalSystem_projective([x^2 + y^2, 6*y^2, 10*x*z + z^2 + y^2])
F.resultant()
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> F = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(6)*y**Integer(2), Integer(10)*x*z + z**Integer(2) + y**Integer(2)])
>>> F.resultant()
1296

P.<x,y,z> = ProjectiveSpace(QQ,2)
F = DynamicalSystem_projective([x^2 + y^2, 6*y^2, 10*x*z + z^2 + y^2])
F.resultant()
sage: # needs sage.rings.number_field
sage: R.<t> = PolynomialRing(QQ)
sage: s = (t^3 + t + 1).roots(QQbar)[0][0]
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([s*x^3 - 13*y^3, y^3 - 15*y^3])
sage: f.resultant()
871.6925062959149?

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> s = (t**Integer(3) + t + Integer(1)).roots(QQbar)[Integer(0)][Integer(0)]
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([s*x**Integer(3) - Integer(13)*y**Integer(3), y**Integer(3) - Integer(15)*y**Integer(3)])
>>> f.resultant()
871.6925062959149?

# needs sage.rings.number_field
R.<t> = PolynomialRing(QQ)
s = (t^3 + t + 1).roots(QQbar)[0][0]
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([s*x^3 - 13*y^3, y^3 - 15*y^3])
f.resultant()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> s = (t**Integer(3) + t + Integer(1)).roots(QQbar)[Integer(0)][Integer(0)]
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([s*x**Integer(3) - Integer(13)*y**Integer(3), y**Integer(3) - Integer(15)*y**Integer(3)])
>>> f.resultant()
871.6925062959149?

# needs sage.rings.number_field
R.<t> = PolynomialRing(QQ)
s = (t^3 + t + 1).roots(QQbar)[0][0]
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([s*x^3 - 13*y^3, y^3 - 15*y^3])
f.resultant()
sigma_invariants(n, formal=False, embedding=None, type='point', return_polynomial=False, chow=False, deform=False, check=True)[source]

Compute the values of the elementary symmetric polynomials evaluated on the n multiplier spectra of this dynamical system.

The sigma invariants are the symmetric polynomials evaluated on the characteristic polynomial of the multipliers. See [Hutz2019] for the full definition. Spepcifically, this function returns either the following polynomial or its coefficients (with signs appropriately adjusted):

\[\prod_{P \text{ period n}} ( w - c(P,t)),\]

where \(c(P,t)\) is the charateristic polynomial (variable \(t\)) of the multiplier at \(P\). Note that in dimension 1, only the coefficients of the constant term is returned.

The invariants can be computed for points of period n or points of formal period n. The base ring should be a number field, number field order, or a finite field or a polynomial ring or function field over a number field, number field order, or finite field.

The parameter type determines if the sigma are computed from the multipliers calculated at one per cycle (with multiplicity) or one per point (with multiplicity). Only implemented for dimension 1. Note that in the cycle case, a map with a cycle which collapses into multiple smaller cycles, this is still considered one cycle. In other words, if a 4-cycle collapses into a 2-cycle with multiplicity 2, there is only one multiplier used for the doubled 2-cycle when computing n=4.

ALGORITHM:

In dimension 1, we use the Poisson product of the resultant of two polynomials:

\[res(f,g) = \prod_{f(a)=0} g(a).\]

In higher dimensions, we use elimination theory (Groebner bases) to compute the equivalent of the Poisson product. Letting \(f\) be the polynomial defining the periodic or formal periodic points and \(g\) the polynomial \(w - F\) for an auxilarly variable \(w\) and \(F\) the characteristic polynomial of the Jacobian matrix of \(f\). Note that if \(f\) is a rational function, we clear denominators for \(g\).

To calculate the full polynomial defining the sigma invariants, we follow the algorithm outlined in section 4 of [Hutz2019]. There are 4 cases:

  • multipliers and n periodic points all distinct – in this case, we can use Proposition 4.1 of [Hutz2019] to compute the sigma invariants

  • n – periodic points are all distinct, multipliers are repeated; here we can use Proposition 4.2 of [Hutz2019] to compute the sigma invariants. This corresponds to chow=True.

  • n – periodic points are repeated, multipliers are all distinct; to deal with this case, we deform the map by a formal parameter \(k\). The deformation separates the n periodic points, making them distinct, and we can recover the n periodic points of the original map by specializing \(k\) to 0. This corresponds to deform=True.

  • n – periodic points are repeated, multipliers are repeated; here we can use both cases 2 and 3 together. This corresponds to deform=True and chow=True.

As we do not want to check which case we are in beforehand, we throw a ValueError if the computed polynomial does not have the correct degree.

INPUT:

  • n – positive integer, the period

  • formal – boolean (default: False); True specifies to find the values of the elementary symmetric polynomials corresponding to the formal n multiplier spectra and False specifies to instead find the values corresponding to the n multiplier spectra, which includes the multipliers of all periodic points of period n

  • embedding – (default: None) must be None, passing an embedding is no longer supported, see Issue #32205

  • type – (default: 'point') string; either 'point' or 'cycle' depending on whether you compute with one multiplier per point or one per cycle. Not implemented for dimension greater than 1.

  • return polynomial – boolean (default: False); True specifies returning the polynomial which generates the sigma invariants, see [Hutz2019] for the full definition. The polynomial is always a multivariate polynomial with variables w and t.

  • chow – boolean (default: False); True specifies using the Chow algorithm from [Hutz2019] to compute the sigma invariants. While slower, the Chow algorithm does not lose information about multiplicities of the multipliers. In order to accurately compute the sigma polynomial when there is a repeated multiplier, chow must be True.

  • deform – boolean (default: False); True specifies first deforming the map so that all periodic points are distinct and then calculating the sigma invariants. In order to accurately calculate the sigma polynomial when there is a periodic point with multiplicity, deform must be True.

  • check – boolean (default: True); when True the degree of the sigma polynomial is checked against the expected degree. This is done as the sigma polynomial may drop degree if multiplicities of periodic points or multipliers are not correctly accounted for using chow or deform.

Warning

Setting check to False can lead to mathematically incorrect answers.

OUTPUT: list of elements in the base ring, unless return_polynomial is True, in which case a polynomial in w and t is returned. The variable t is the variable of the characteristic polynomials of the multipliers.

If this map is defined over \(\mathbb{P}^N\), where \(N > 1\), then the list is the coefficients of \(w\) and \(t\), in lexographical order with \(w > t\).

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y + y^2, y^2 + x*y])
sage: f.sigma_invariants(1)                                                 # needs sage.rings.number_field
[3, 3, 1]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y + y**Integer(2), y**Integer(2) + x*y])
>>> f.sigma_invariants(Integer(1))                                                 # needs sage.rings.number_field
[3, 3, 1]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y + y^2, y^2 + x*y])
f.sigma_invariants(1)                                                 # needs sage.rings.number_field

If return_polynomial is True, then following [Hutz2019] we return a two variable polynomial in \(w\) and \(t\):

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 2*y^2, y^2])
sage: poly = f.sigma_invariants(1, return_polynomial=True); poly
w^3 - 3*w^2*t + 2*w^2 + 3*w*t^2 - 4*w*t + 8*w - t^3 + 2*t^2 - 8*t

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(2)*y**Integer(2), y**Integer(2)])
>>> poly = f.sigma_invariants(Integer(1), return_polynomial=True); poly
w^3 - 3*w^2*t + 2*w^2 + 3*w*t^2 - 4*w*t + 8*w - t^3 + 2*t^2 - 8*t

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 2*y^2, y^2])
poly = f.sigma_invariants(1, return_polynomial=True); poly

From the full polynomial, we can easily recover the one variable polynomial whose coefficients are symmetric functions in the multipliers, up to sign:

sage: w, t = poly.variables()
sage: poly.specialization({w:0}).monic()
t^3 - 2*t^2 + 8*t
sage: f.sigma_invariants(1)                                                 # needs sage.rings.number_field
[2, 8, 0]

>>> from sage.all import *
>>> w, t = poly.variables()
>>> poly.specialization({w:Integer(0)}).monic()
t^3 - 2*t^2 + 8*t
>>> f.sigma_invariants(Integer(1))                                                 # needs sage.rings.number_field
[2, 8, 0]

w, t = poly.variables()
poly.specialization({w:0}).monic()
f.sigma_invariants(1)                                                 # needs sage.rings.number_field

For dynamical systems on \(\mathbb{P}^N\), where \(N > 1\), the full polynomial is needed to distinguish the conjugacy class. We can, however, still return a list in this case:

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, z^2, y^2])
sage: f.sigma_invariants(1, chow=True)
[1, 7, -6, -12, 21, -36, -60, 72, 48, 35, -90, -120, 352, 96, -288, -64, 35,
 -120, -120, 688, -96, -1056, 320, 384, 0, 21, -90, -60, 672, -384, -1440, 1344,
 768, -768, 0, 0, 7, -36, -12, 328, -336, -864, 1472, 384, -1536, 512, 0, 0, 0,
 1, -6, 0, 64, -96, -192, 512, 0, -768, 512, 0, 0, 0, 0, 0]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), z**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(1), chow=True)
[1, 7, -6, -12, 21, -36, -60, 72, 48, 35, -90, -120, 352, 96, -288, -64, 35,
 -120, -120, 688, -96, -1056, 320, 384, 0, 21, -90, -60, 672, -384, -1440, 1344,
 768, -768, 0, 0, 7, -36, -12, 328, -336, -864, 1472, 384, -1536, 512, 0, 0, 0,
 1, -6, 0, 64, -96, -192, 512, 0, -768, 512, 0, 0, 0, 0, 0]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, z^2, y^2])
f.sigma_invariants(1, chow=True)

When calculating the sigma invariants for \(\mathbb{P}^N\), with \(N > 1\), the default algorithm loses information about multiplicities. Note that the following call to sigma invariants returns a degree 6 polynomial in \(w\):

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2])
sage: f.sigma_invariants(1, return_polynomial=True, check=False)
w^6 - 6*w^5*t^2 + 8*w^5*t - 4*w^5 + 15*w^4*t^4 - 40*w^4*t^3 + 40*w^4*t^2 -
16*w^4*t - 20*w^3*t^6 + 80*w^3*t^5 - 120*w^3*t^4 + 80*w^3*t^3 - 16*w^3*t^2 +
15*w^2*t^8 - 80*w^2*t^7 + 160*w^2*t^6 - 144*w^2*t^5 + 48*w^2*t^4 - 6*w*t^10 +
40*w*t^9 - 100*w*t^8 + 112*w*t^7 - 48*w*t^6 + t^12 - 8*t^11 + 24*t^10 -
32*t^9 + 16*t^8

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.sigma_invariants(Integer(1), return_polynomial=True, check=False)
w^6 - 6*w^5*t^2 + 8*w^5*t - 4*w^5 + 15*w^4*t^4 - 40*w^4*t^3 + 40*w^4*t^2 -
16*w^4*t - 20*w^3*t^6 + 80*w^3*t^5 - 120*w^3*t^4 + 80*w^3*t^3 - 16*w^3*t^2 +
15*w^2*t^8 - 80*w^2*t^7 + 160*w^2*t^6 - 144*w^2*t^5 + 48*w^2*t^4 - 6*w*t^10 +
40*w*t^9 - 100*w*t^8 + 112*w*t^7 - 48*w*t^6 + t^12 - 8*t^11 + 24*t^10 -
32*t^9 + 16*t^8

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2, y^2, z^2])
f.sigma_invariants(1, return_polynomial=True, check=False)

Setting chow to True, while much slower, accounts correctly for multiplicities. Note that the following returns a degree 7 polynomial in \(w\):

sage: f.sigma_invariants(1, return_polynomial=True, chow=True)
w^7 - 7*w^6*t^2 + 10*w^6*t - 4*w^6 + 21*w^5*t^4 - 60*w^5*t^3 + 60*w^5*t^2 -
24*w^5*t - 35*w^4*t^6 + 150*w^4*t^5 - 240*w^4*t^4 + 176*w^4*t^3 - 48*w^4*t^2 +
35*w^3*t^8 - 200*w^3*t^7 + 440*w^3*t^6 - 464*w^3*t^5 + 224*w^3*t^4 -
32*w^3*t^3 - 21*w^2*t^10 + 150*w^2*t^9 - 420*w^2*t^8 + 576*w^2*t^7 -
384*w^2*t^6 + 96*w^2*t^5 + 7*w*t^12 - 60*w*t^11 + 204*w*t^10 - 344*w*t^9 +
288*w*t^8 - 96*w*t^7 - t^14 + 10*t^13 - 40*t^12 + 80*t^11 - 80*t^10 + 32*t^9

>>> from sage.all import *
>>> f.sigma_invariants(Integer(1), return_polynomial=True, chow=True)
w^7 - 7*w^6*t^2 + 10*w^6*t - 4*w^6 + 21*w^5*t^4 - 60*w^5*t^3 + 60*w^5*t^2 -
24*w^5*t - 35*w^4*t^6 + 150*w^4*t^5 - 240*w^4*t^4 + 176*w^4*t^3 - 48*w^4*t^2 +
35*w^3*t^8 - 200*w^3*t^7 + 440*w^3*t^6 - 464*w^3*t^5 + 224*w^3*t^4 -
32*w^3*t^3 - 21*w^2*t^10 + 150*w^2*t^9 - 420*w^2*t^8 + 576*w^2*t^7 -
384*w^2*t^6 + 96*w^2*t^5 + 7*w*t^12 - 60*w*t^11 + 204*w*t^10 - 344*w*t^9 +
288*w*t^8 - 96*w*t^7 - t^14 + 10*t^13 - 40*t^12 + 80*t^11 - 80*t^10 + 32*t^9

f.sigma_invariants(1, return_polynomial=True, chow=True)
sage: # needs sage.rings.number_field
sage: set_verbose(None)
sage: z = QQ['z'].0
sage: K = NumberField(z^4 - 4*z^2 + 1, 'z')
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 - 5/4*y^2, y^2])
sage: f.sigma_invariants(2, formal=False, type='cycle')
[13, 11, -25, 0]
sage: f.sigma_invariants(2, formal=False, type='point')
[12, -2, -36, 25, 0]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> z = QQ['z'].gen(0)
>>> K = NumberField(z**Integer(4) - Integer(4)*z**Integer(2) + Integer(1), 'z')
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(5)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(2), formal=False, type='cycle')
[13, 11, -25, 0]
>>> f.sigma_invariants(Integer(2), formal=False, type='point')
[12, -2, -36, 25, 0]

# needs sage.rings.number_field
set_verbose(None)
z = QQ['z'].0
K = NumberField(z^4 - 4*z^2 + 1, 'z')
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - 5/4*y^2, y^2])
f.sigma_invariants(2, formal=False, type='cycle')
f.sigma_invariants(2, formal=False, type='point')
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> z = QQ['z'].gen(0)
>>> K = NumberField(z**Integer(4) - Integer(4)*z**Integer(2) + Integer(1), 'z')
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(5)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(2), formal=False, type='cycle')
[13, 11, -25, 0]
>>> f.sigma_invariants(Integer(2), formal=False, type='point')
[12, -2, -36, 25, 0]

# needs sage.rings.number_field
set_verbose(None)
z = QQ['z'].0
K = NumberField(z^4 - 4*z^2 + 1, 'z')
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - 5/4*y^2, y^2])
f.sigma_invariants(2, formal=False, type='cycle')
f.sigma_invariants(2, formal=False, type='point')

check that infinity as part of a longer cycle is handled correctly:

sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([y^2, x^2])
sage: f.sigma_invariants(2, type='cycle')
[12, 48, 64, 0]
sage: f.sigma_invariants(2, type='point')
[12, 48, 64, 0, 0]
sage: f.sigma_invariants(2, type='cycle', formal=True)
[0]
sage: f.sigma_invariants(2, type='point', formal=True)
[0, 0]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> f.sigma_invariants(Integer(2), type='cycle')
[12, 48, 64, 0]
>>> f.sigma_invariants(Integer(2), type='point')
[12, 48, 64, 0, 0]
>>> f.sigma_invariants(Integer(2), type='cycle', formal=True)
[0]
>>> f.sigma_invariants(Integer(2), type='point', formal=True)
[0, 0]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([y^2, x^2])
f.sigma_invariants(2, type='cycle')
f.sigma_invariants(2, type='point')
f.sigma_invariants(2, type='cycle', formal=True)
f.sigma_invariants(2, type='point', formal=True)
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(3)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 - w*y^2, (1-w)*x*y])
sage: f.sigma_invariants(2, formal=False, type='cycle')
[6*w + 21, 78*w + 159, 210*w + 367, 90*w + 156]
sage: f.sigma_invariants(2, formal=False, type='point')
[6*w + 24, 96*w + 222, 444*w + 844, 720*w + 1257, 270*w + 468]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - w*y**Integer(2), (Integer(1)-w)*x*y])
>>> f.sigma_invariants(Integer(2), formal=False, type='cycle')
[6*w + 21, 78*w + 159, 210*w + 367, 90*w + 156]
>>> f.sigma_invariants(Integer(2), formal=False, type='point')
[6*w + 24, 96*w + 222, 444*w + 844, 720*w + 1257, 270*w + 468]

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - w*y^2, (1-w)*x*y])
f.sigma_invariants(2, formal=False, type='cycle')
f.sigma_invariants(2, formal=False, type='point')
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - w*y**Integer(2), (Integer(1)-w)*x*y])
>>> f.sigma_invariants(Integer(2), formal=False, type='cycle')
[6*w + 21, 78*w + 159, 210*w + 367, 90*w + 156]
>>> f.sigma_invariants(Integer(2), formal=False, type='point')
[6*w + 24, 96*w + 222, 444*w + 844, 720*w + 1257, 270*w + 468]

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 - w*y^2, (1-w)*x*y])
f.sigma_invariants(2, formal=False, type='cycle')
f.sigma_invariants(2, formal=False, type='point')
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([512*x^5 - 378128*x^4*y + 76594292*x^3*y^2
....:         - 4570550136*x^2*y^3 - 2630045017*x*y^4 + 28193217129*y^5, 512*y^5])
sage: f.sigma_invariants(1)                                                 # needs sage.rings.number_field
[19575526074450617/1048576, -9078122048145044298567432325/2147483648,
 -2622661114909099878224381377917540931367/1099511627776,
 -2622661107937102104196133701280271632423/549755813888,
 338523204830161116503153209450763500631714178825448006778305/72057594037927936, 0]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(512)*x**Integer(5) - Integer(378128)*x**Integer(4)*y + Integer(76594292)*x**Integer(3)*y**Integer(2)
...         - Integer(4570550136)*x**Integer(2)*y**Integer(3) - Integer(2630045017)*x*y**Integer(4) + Integer(28193217129)*y**Integer(5), Integer(512)*y**Integer(5)])
>>> f.sigma_invariants(Integer(1))                                                 # needs sage.rings.number_field
[19575526074450617/1048576, -9078122048145044298567432325/2147483648,
 -2622661114909099878224381377917540931367/1099511627776,
 -2622661107937102104196133701280271632423/549755813888,
 338523204830161116503153209450763500631714178825448006778305/72057594037927936, 0]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([512*x^5 - 378128*x^4*y + 76594292*x^3*y^2
        - 4570550136*x^2*y^3 - 2630045017*x*y^4 + 28193217129*y^5, 512*y^5])
f.sigma_invariants(1)                                                 # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(512)*x**Integer(5) - Integer(378128)*x**Integer(4)*y + Integer(76594292)*x**Integer(3)*y**Integer(2)
...         - Integer(4570550136)*x**Integer(2)*y**Integer(3) - Integer(2630045017)*x*y**Integer(4) + Integer(28193217129)*y**Integer(5), Integer(512)*y**Integer(5)])
>>> f.sigma_invariants(Integer(1))                                                 # needs sage.rings.number_field
[19575526074450617/1048576, -9078122048145044298567432325/2147483648,
 -2622661114909099878224381377917540931367/1099511627776,
 -2622661107937102104196133701280271632423/549755813888,
 338523204830161116503153209450763500631714178825448006778305/72057594037927936, 0]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([512*x^5 - 378128*x^4*y + 76594292*x^3*y^2
        - 4570550136*x^2*y^3 - 2630045017*x*y^4 + 28193217129*y^5, 512*y^5])
f.sigma_invariants(1)                                                 # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(GF(5), 2)
sage: f = DynamicalSystem([x^2, y^2, z^2])
sage: f.sigma_invariants(1, chow=True, return_polynomial=True)
w^7 - 2*w^6*t^2 + w^6 + w^5*t^4 + w^5*t + w^4*t^3 + 2*w^4*t^2 + w^3*t^5 -
w^3*t^4 - 2*w^3*t^3 - w^2*t^10 + w^2*t^7 + w^2*t^6 + w^2*t^5 + 2*w*t^12 -
w*t^10 + w*t^9 - 2*w*t^8 - w*t^7 - t^14 + 2*t^9

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.sigma_invariants(Integer(1), chow=True, return_polynomial=True)
w^7 - 2*w^6*t^2 + w^6 + w^5*t^4 + w^5*t + w^4*t^3 + 2*w^4*t^2 + w^3*t^5 -
w^3*t^4 - 2*w^3*t^3 - w^2*t^10 + w^2*t^7 + w^2*t^6 + w^2*t^5 + 2*w*t^12 -
w*t^10 + w*t^9 - 2*w*t^8 - w*t^7 - t^14 + 2*t^9

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem([x^2, y^2, z^2])
f.sigma_invariants(1, chow=True, return_polynomial=True)
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2), y**Integer(2), z**Integer(2)])
>>> f.sigma_invariants(Integer(1), chow=True, return_polynomial=True)
w^7 - 2*w^6*t^2 + w^6 + w^5*t^4 + w^5*t + w^4*t^3 + 2*w^4*t^2 + w^3*t^5 -
w^3*t^4 - 2*w^3*t^3 - w^2*t^10 + w^2*t^7 + w^2*t^6 + w^2*t^5 + 2*w*t^12 -
w*t^10 + w*t^9 - 2*w*t^8 - w*t^7 - t^14 + 2*t^9

P.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem([x^2, y^2, z^2])
f.sigma_invariants(1, chow=True, return_polynomial=True)
sage: # needs sage.rings.number_field
sage: R.<c> = QQ[]
sage: Pc.<x,y> = ProjectiveSpace(R, 1)
sage: f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
sage: f.sigma_invariants(1)
[2, 4*c, 0]
sage: f.sigma_invariants(2, formal=True, type='point')
[8*c + 8, 16*c^2 + 32*c + 16]
sage: f.sigma_invariants(2, formal=True, type='cycle')
[4*c + 4]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['c']; (c,) = R._first_ngens(1)
>>> Pc = ProjectiveSpace(R, Integer(1), names=('x', 'y',)); (x, y,) = Pc._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(1))
[2, 4*c, 0]
>>> f.sigma_invariants(Integer(2), formal=True, type='point')
[8*c + 8, 16*c^2 + 32*c + 16]
>>> f.sigma_invariants(Integer(2), formal=True, type='cycle')
[4*c + 4]

# needs sage.rings.number_field
R.<c> = QQ[]
Pc.<x,y> = ProjectiveSpace(R, 1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.sigma_invariants(1)
f.sigma_invariants(2, formal=True, type='point')
f.sigma_invariants(2, formal=True, type='cycle')
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['c']; (c,) = R._first_ngens(1)
>>> Pc = ProjectiveSpace(R, Integer(1), names=('x', 'y',)); (x, y,) = Pc._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(1))
[2, 4*c, 0]
>>> f.sigma_invariants(Integer(2), formal=True, type='point')
[8*c + 8, 16*c^2 + 32*c + 16]
>>> f.sigma_invariants(Integer(2), formal=True, type='cycle')
[4*c + 4]

# needs sage.rings.number_field
R.<c> = QQ[]
Pc.<x,y> = ProjectiveSpace(R, 1)
f = DynamicalSystem_projective([x^2 + c*y^2, y^2])
f.sigma_invariants(1)
f.sigma_invariants(2, formal=True, type='point')
f.sigma_invariants(2, formal=True, type='cycle')
sage: R.<c> = QQ[]
sage: P.<x,y> = ProjectiveSpace(R, 1)
sage: f = DynamicalSystem([x^2 + c*y^2, y^2])
sage: f.sigma_invariants(1, return_polynomial=True)
w^3 + (-3)*w^2*t + 2*w^2 + 3*w*t^2 + (-4)*w*t + 4*c*w - t^3 + 2*t^2 + (-4*c)*t
sage: f.sigma_invariants(2, chow=True, formal=True,                         # needs sage.libs.pari
....:                    return_polynomial=True)
w^2 + (-2)*w*t + (8*c + 8)*w + t^2 + (-8*c - 8)*t + 16*c^2 + 32*c + 16

>>> from sage.all import *
>>> R = QQ['c']; (c,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(1), return_polynomial=True)
w^3 + (-3)*w^2*t + 2*w^2 + 3*w*t^2 + (-4)*w*t + 4*c*w - t^3 + 2*t^2 + (-4*c)*t
>>> f.sigma_invariants(Integer(2), chow=True, formal=True,                         # needs sage.libs.pari
...                    return_polynomial=True)
w^2 + (-2)*w*t + (8*c + 8)*w + t^2 + (-8*c - 8)*t + 16*c^2 + 32*c + 16

R.<c> = QQ[]
P.<x,y> = ProjectiveSpace(R, 1)
f = DynamicalSystem([x^2 + c*y^2, y^2])
f.sigma_invariants(1, return_polynomial=True)
f.sigma_invariants(2, chow=True, formal=True,                         # needs sage.libs.pari
                   return_polynomial=True)
>>> from sage.all import *
>>> R = QQ['c']; (c,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + c*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(1), return_polynomial=True)
w^3 + (-3)*w^2*t + 2*w^2 + 3*w*t^2 + (-4)*w*t + 4*c*w - t^3 + 2*t^2 + (-4*c)*t
>>> f.sigma_invariants(Integer(2), chow=True, formal=True,                         # needs sage.libs.pari
...                    return_polynomial=True)
w^2 + (-2)*w*t + (8*c + 8)*w + t^2 + (-8*c - 8)*t + 16*c^2 + 32*c + 16

R.<c> = QQ[]
P.<x,y> = ProjectiveSpace(R, 1)
f = DynamicalSystem([x^2 + c*y^2, y^2])
f.sigma_invariants(1, return_polynomial=True)
f.sigma_invariants(2, chow=True, formal=True,                         # needs sage.libs.pari
                   return_polynomial=True)
sage: R.<c,d> = QQ[]
sage: P.<x,y,z> = ProjectiveSpace(R, 2)
sage: f = DynamicalSystem([x^2 + c*z^2, y^2 + d*z^2, z^2])
sage: len(dict(f.sigma_invariants(1, return_polynomial=True)))
51

>>> from sage.all import *
>>> R = QQ['c, d']; (c, d,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2) + c*z**Integer(2), y**Integer(2) + d*z**Integer(2), z**Integer(2)])
>>> len(dict(f.sigma_invariants(Integer(1), return_polynomial=True)))
51

R.<c,d> = QQ[]
P.<x,y,z> = ProjectiveSpace(R, 2)
f = DynamicalSystem([x^2 + c*z^2, y^2 + d*z^2, z^2])
len(dict(f.sigma_invariants(1, return_polynomial=True)))
>>> from sage.all import *
>>> R = QQ['c, d']; (c, d,) = R._first_ngens(2)
>>> P = ProjectiveSpace(R, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem([x**Integer(2) + c*z**Integer(2), y**Integer(2) + d*z**Integer(2), z**Integer(2)])
>>> len(dict(f.sigma_invariants(Integer(1), return_polynomial=True)))
51

R.<c,d> = QQ[]
P.<x,y,z> = ProjectiveSpace(R, 2)
f = DynamicalSystem([x^2 + c*z^2, y^2 + d*z^2, z^2])
len(dict(f.sigma_invariants(1, return_polynomial=True)))
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem([x^2 + 3*y^2, x*y])
sage: f.sigma_invariants(1, deform=True, return_polynomial=True)            # needs sage.rings.function_field
w^3 - 3*w^2*t + 3*w^2 + 3*w*t^2 - 6*w*t + 3*w - t^3 + 3*t^2 - 3*t + 1

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + Integer(3)*y**Integer(2), x*y])
>>> f.sigma_invariants(Integer(1), deform=True, return_polynomial=True)            # needs sage.rings.function_field
w^3 - 3*w^2*t + 3*w^2 + 3*w*t^2 - 6*w*t + 3*w - t^3 + 3*t^2 - 3*t + 1

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([x^2 + 3*y^2, x*y])
f.sigma_invariants(1, deform=True, return_polynomial=True)            # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([x**Integer(2) + Integer(3)*y**Integer(2), x*y])
>>> f.sigma_invariants(Integer(1), deform=True, return_polynomial=True)            # needs sage.rings.function_field
w^3 - 3*w^2*t + 3*w^2 + 3*w*t^2 - 6*w*t + 3*w - t^3 + 3*t^2 - 3*t + 1

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem([x^2 + 3*y^2, x*y])
f.sigma_invariants(1, deform=True, return_polynomial=True)            # needs sage.rings.function_field

doubled fixed point:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sage: f.sigma_invariants(2, formal=True)                                    # needs sage.rings.number_field
[2, 1]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(2), formal=True)                                    # needs sage.rings.number_field
[2, 1]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
f.sigma_invariants(2, formal=True)                                    # needs sage.rings.number_field

doubled 2 cycle:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 5/4*y^2, y^2])
sage: f.sigma_invariants(4, formal=False, type='cycle')                     # needs sage.rings.number_field
[170, 5195, 172700, 968615, 1439066, 638125, 0]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(5)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> f.sigma_invariants(Integer(4), formal=False, type='cycle')                     # needs sage.rings.number_field
[170, 5195, 172700, 968615, 1439066, 638125, 0]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 5/4*y^2, y^2])
f.sigma_invariants(4, formal=False, type='cycle')                     # needs sage.rings.number_field
class sage.dynamics.arithmetic_dynamics.projective_ds.DynamicalSystem_projective_field(polys, domain)[source]

Bases: DynamicalSystem_projective, SchemeMorphism_polynomial_projective_space_field

all_periodic_points(**kwds)[source]

Determine the set of rational periodic points for this dynamical system.

The map must be defined over \(\QQ\) and be an endomorphism of projective space. If the map is a polynomial endomorphism of \(\mathbb{P}^1\), i.e. has a totally ramified fixed point, then the base ring can be an absolute number field. This is done by passing to the Weil restriction.

The default parameter values are typically good choices for \(\mathbb{P}^1\). If you are having trouble getting a particular map to finish, try first computing the possible periods, then try various different lifting_prime values.

ALGORITHM:

Modulo each prime of good reduction \(p\) determine the set of periodic points modulo \(p\). For each cycle modulo \(p\) compute the set of possible periods (\(mrp^e\)). Take the intersection of the list of possible periods modulo several primes of good reduction to get a possible list of minimal periods of rational periodic points. Take each point modulo \(p\) associated to each of these possible periods and try to lift it to a rational point with a combination of \(p\)-adic approximation and the LLL basis reduction algorithm.

See [Hutz2015].

INPUT: keyword arguments:

  • R – (default: domain of dynamical system) the base ring over which the periodic points of the dynamical system are found

  • prime_bound – (default: [1,20]) a pair (list or tuple) of positive integers that represent the limits of primes to use in the reduction step or an integer that represents the upper bound

  • lifting_prime – (default: 23) a prime integer; argument that specifies modulo which prime to try and perform the lifting

  • period_degree_bounds – (default: [4,4]) a pair of positive integers (max period, max degree) for which the dynatomic polynomial should be solved for

  • algorithm – (optional) specifies which algorithm to use; current options are \(dynatomic\) and \(lifting\); defaults to solving the dynatomic for low periods and degrees and lifts for everything else

  • periods – (optional) a list of positive integers that is the list of possible periods

  • bad_primes – (optional) a list or tuple of integer primes; the primes of bad reduction

  • ncpus – (default: all cpus) number of cpus to use in parallel

OUTPUT: list of rational points in projective space

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sage: sorted(f.all_periodic_points(prime_bound=20, lifting_prime=7))  # long time
[(-1/2 : 1), (1 : 0), (3/2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.all_periodic_points(prime_bound=Integer(20), lifting_prime=Integer(7)))  # long time
[(-1/2 : 1), (1 : 0), (3/2 : 1)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sorted(f.all_periodic_points(prime_bound=20, lifting_prime=7))  # long time
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
....:                                 5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
sage: sorted(f.all_periodic_points(prime_bound=[1,20])) # long time
[(-3 : -1 : 1), (-3 : 0 : 1), (-3 : 1 : 1), (-3 : 3 : 1), (-1 : -1 : 1),
 (-1 : 0 : 1), (-1 : 1 : 1), (-1 : 3 : 1), (0 : 1 : 0), (1 : -1 : 1),
 (1 : 0 : 0), (1 : 0 : 1), (1 : 1 : 1), (1 : 3 : 1), (3 : -1 : 1),
 (3 : 0 : 1), (3 : 1 : 1), (3 : 3 : 1), (5 : -1 : 1), (5 : 0 : 1),
 (5 : 1 : 1), (5 : 3 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> sorted(f.all_periodic_points(prime_bound=[Integer(1),Integer(20)])) # long time
[(-3 : -1 : 1), (-3 : 0 : 1), (-3 : 1 : 1), (-3 : 3 : 1), (-1 : -1 : 1),
 (-1 : 0 : 1), (-1 : 1 : 1), (-1 : 3 : 1), (0 : 1 : 0), (1 : -1 : 1),
 (1 : 0 : 0), (1 : 0 : 1), (1 : 1 : 1), (1 : 3 : 1), (3 : -1 : 1),
 (3 : 0 : 1), (3 : 1 : 1), (3 : 3 : 1), (5 : -1 : 1), (5 : 0 : 1),
 (5 : 1 : 1), (5 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
sorted(f.all_periodic_points(prime_bound=[1,20])) # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> sorted(f.all_periodic_points(prime_bound=[Integer(1),Integer(20)])) # long time
[(-3 : -1 : 1), (-3 : 0 : 1), (-3 : 1 : 1), (-3 : 3 : 1), (-1 : -1 : 1),
 (-1 : 0 : 1), (-1 : 1 : 1), (-1 : 3 : 1), (0 : 1 : 0), (1 : -1 : 1),
 (1 : 0 : 0), (1 : 0 : 1), (1 : 1 : 1), (1 : 3 : 1), (3 : -1 : 1),
 (3 : 0 : 1), (3 : 1 : 1), (3 : 3 : 1), (5 : -1 : 1), (5 : 0 : 1),
 (5 : 1 : 1), (5 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
sorted(f.all_periodic_points(prime_bound=[1,20])) # long time
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([-5*x^2 + 4*y^2, 4*x*y])
sage: sorted(f.all_periodic_points())  # long time
[(-2 : 1), (-2/3 : 1), (2/3 : 1), (1 : 0), (2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(5)*x**Integer(2) + Integer(4)*y**Integer(2), Integer(4)*x*y])
>>> sorted(f.all_periodic_points())  # long time
[(-2 : 1), (-2/3 : 1), (2/3 : 1), (1 : 0), (2 : 1)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([-5*x^2 + 4*y^2, 4*x*y])
sorted(f.all_periodic_points())  # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(5)*x**Integer(2) + Integer(4)*y**Integer(2), Integer(4)*x*y])
>>> sorted(f.all_periodic_points())  # long time
[(-2 : 1), (-2/3 : 1), (2/3 : 1), (1 : 0), (2 : 1)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([-5*x^2 + 4*y^2, 4*x*y])
sorted(f.all_periodic_points())  # long time
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = NumberField(x^2 - x + 1)
sage: P.<u,v> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([u^2 + v^2, v^2])
sage: sorted(f.all_periodic_points())                                       # needs sage.rings.function_field
[(-w + 1 : 1), (w : 1), (1 : 0)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), v**Integer(2)])
>>> sorted(f.all_periodic_points())                                       # needs sage.rings.function_field
[(-w + 1 : 1), (w : 1), (1 : 0)]

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - x + 1)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, v^2])
sorted(f.all_periodic_points())                                       # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), v**Integer(2)])
>>> sorted(f.all_periodic_points())                                       # needs sage.rings.function_field
[(-w + 1 : 1), (w : 1), (1 : 0)]

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - x + 1)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, v^2])
sorted(f.all_periodic_points())                                       # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = NumberField(x^2 - x + 1)
sage: P.<u,v> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([u^2 + v^2, u*v])
sage: f.all_periodic_points()                                               # needs sage.rings.function_field
Traceback (most recent call last):
...
NotImplementedError: rational periodic points for number fields
only implemented for polynomials

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), u*v])
>>> f.all_periodic_points()                                               # needs sage.rings.function_field
Traceback (most recent call last):
...
NotImplementedError: rational periodic points for number fields
only implemented for polynomials

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - x + 1)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, u*v])
f.all_periodic_points()                                               # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - x + Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), u*v])
>>> f.all_periodic_points()                                               # needs sage.rings.function_field
Traceback (most recent call last):
...
NotImplementedError: rational periodic points for number fields
only implemented for polynomials

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - x + 1)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, u*v])
f.all_periodic_points()                                               # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: K.<v> = QuadraticField(5)
sage: phi = QQ.embeddings(K)[0]
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: sorted(f.all_periodic_points(R=phi))
[(-1 : 1), (-1/2*v + 1/2 : 1), (0 : 1), (1 : 0), (1/2*v + 1/2 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> K = QuadraticField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = QQ.embeddings(K)[Integer(0)]
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> sorted(f.all_periodic_points(R=phi))
[(-1 : 1), (-1/2*v + 1/2 : 1), (0 : 1), (1 : 0), (1/2*v + 1/2 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
K.<v> = QuadraticField(5)
phi = QQ.embeddings(K)[0]
f = DynamicalSystem_projective([x^2 - y^2, y^2])
sorted(f.all_periodic_points(R=phi))
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> K = QuadraticField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> phi = QQ.embeddings(K)[Integer(0)]
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> sorted(f.all_periodic_points(R=phi))
[(-1 : 1), (-1/2*v + 1/2 : 1), (0 : 1), (1 : 0), (1/2*v + 1/2 : 1)]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
K.<v> = QuadraticField(5)
phi = QQ.embeddings(K)[0]
f = DynamicalSystem_projective([x^2 - y^2, y^2])
sorted(f.all_periodic_points(R=phi))
sage: P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
sage: f = DynamicalSystem_projective([x^2 - (3/4)*w^2, y^2 - 3/4*w^2,
....:                                 z^2 - 3/4*w^2, w^2])
sage: sorted(f.all_periodic_points(algorithm='dynatomic'))                  # needs sage.rings.function_field
[(-1/2 : -1/2 : -1/2 : 1),
 (-1/2 : -1/2 : 3/2 : 1),
 (-1/2 : 3/2 : -1/2 : 1),
 (-1/2 : 3/2 : 3/2 : 1),
 (0 : 0 : 1 : 0),
 (0 : 1 : 0 : 0),
 (0 : 1 : 1 : 0),
 (1 : 0 : 0 : 0),
 (1 : 0 : 1 : 0),
 (1 : 1 : 0 : 0),
 (1 : 1 : 1 : 0),
 (3/2 : -1/2 : -1/2 : 1),
 (3/2 : -1/2 : 3/2 : 1),
 (3/2 : 3/2 : -1/2 : 1),
 (3/2 : 3/2 : 3/2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([x**Integer(2) - (Integer(3)/Integer(4))*w**Integer(2), y**Integer(2) - Integer(3)/Integer(4)*w**Integer(2),
...                                 z**Integer(2) - Integer(3)/Integer(4)*w**Integer(2), w**Integer(2)])
>>> sorted(f.all_periodic_points(algorithm='dynatomic'))                  # needs sage.rings.function_field
[(-1/2 : -1/2 : -1/2 : 1),
 (-1/2 : -1/2 : 3/2 : 1),
 (-1/2 : 3/2 : -1/2 : 1),
 (-1/2 : 3/2 : 3/2 : 1),
 (0 : 0 : 1 : 0),
 (0 : 1 : 0 : 0),
 (0 : 1 : 1 : 0),
 (1 : 0 : 0 : 0),
 (1 : 0 : 1 : 0),
 (1 : 1 : 0 : 0),
 (1 : 1 : 1 : 0),
 (3/2 : -1/2 : -1/2 : 1),
 (3/2 : -1/2 : 3/2 : 1),
 (3/2 : 3/2 : -1/2 : 1),
 (3/2 : 3/2 : 3/2 : 1)]

P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
f = DynamicalSystem_projective([x^2 - (3/4)*w^2, y^2 - 3/4*w^2,
                                z^2 - 3/4*w^2, w^2])
sorted(f.all_periodic_points(algorithm='dynatomic'))                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([x**Integer(2) - (Integer(3)/Integer(4))*w**Integer(2), y**Integer(2) - Integer(3)/Integer(4)*w**Integer(2),
...                                 z**Integer(2) - Integer(3)/Integer(4)*w**Integer(2), w**Integer(2)])
>>> sorted(f.all_periodic_points(algorithm='dynatomic'))                  # needs sage.rings.function_field
[(-1/2 : -1/2 : -1/2 : 1),
 (-1/2 : -1/2 : 3/2 : 1),
 (-1/2 : 3/2 : -1/2 : 1),
 (-1/2 : 3/2 : 3/2 : 1),
 (0 : 0 : 1 : 0),
 (0 : 1 : 0 : 0),
 (0 : 1 : 1 : 0),
 (1 : 0 : 0 : 0),
 (1 : 0 : 1 : 0),
 (1 : 1 : 0 : 0),
 (1 : 1 : 1 : 0),
 (3/2 : -1/2 : -1/2 : 1),
 (3/2 : -1/2 : 3/2 : 1),
 (3/2 : 3/2 : -1/2 : 1),
 (3/2 : 3/2 : 3/2 : 1)]

P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
f = DynamicalSystem_projective([x^2 - (3/4)*w^2, y^2 - 3/4*w^2,
                                z^2 - 3/4*w^2, w^2])
sorted(f.all_periodic_points(algorithm='dynatomic'))                  # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sage: sorted(f.all_periodic_points(period_degree_bounds=[2,2]))             # needs sage.rings.function_field
[(-1/2 : 1), (1 : 0), (3/2 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.all_periodic_points(period_degree_bounds=[Integer(2),Integer(2)]))             # needs sage.rings.function_field
[(-1/2 : 1), (1 : 0), (3/2 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sorted(f.all_periodic_points(period_degree_bounds=[2,2]))             # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(3)/Integer(4)*y**Integer(2), y**Integer(2)])
>>> sorted(f.all_periodic_points(period_degree_bounds=[Integer(2),Integer(2)]))             # needs sage.rings.function_field
[(-1/2 : 1), (1 : 0), (3/2 : 1)]

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 3/4*y^2, y^2])
sorted(f.all_periodic_points(period_degree_bounds=[2,2]))             # needs sage.rings.function_field
all_preperiodic_points(**kwds)[source]

Determine the set of rational preperiodic points for this dynamical system.

The map must be defined over \(\QQ\) and be an endomorphism of projective space. If the map is a polynomial endomorphism of \(\mathbb{P}^1\), i.e. has a totally ramified fixed point, then the base ring can be an absolute number field. This is done by passing to the Weil restriction.

The default parameter values are typically good choices for \(\mathbb{P}^1\). If you are having trouble getting a particular map to finish, try first computing the possible periods, then try various different values for lifting_prime.

ALGORITHM:

  • Determines the list of possible periods.

  • Determines the rational periodic points from the possible periods.

  • Determines the rational preperiodic points from the rational periodic points by determining rational preimages.

INPUT: keyword arguments:

  • R – (default: domain of dynamical system) the base ring over which the periodic points of the dynamical system are found

  • prime_bound – (default: [1, 20]) a pair (list or tuple) of positive integers that represent the limits of primes to use in the reduction step or an integer that represents the upper bound

  • lifting_prime – (default: 23) a prime integer; specifies modulo which prime to try and perform the lifting

  • periods – (optional) a list of positive integers that is the list of possible periods

  • bad_primes – (optional) a list or tuple of integer primes; the primes of bad reduction

  • ncpus – (default: all cpus) number of cpus to use in parallel

  • period_degree_bounds – (default: [4,4]) a pair of positive integers (max period, max degree) for which the dynatomic polynomial should be solved for when in dimension 1

  • algorithm – (optional) specifies which algorithm to use; current options are \(dynatomic\) and \(lifting\); defaults to solving the dynatomic for low periods and degrees and lifts for everything else

OUTPUT: list of rational points in projective space

EXAMPLES:

sage: PS.<x,y> = ProjectiveSpace(1,QQ)
sage: f = DynamicalSystem_projective([x^2 - y^2, 3*x*y])
sage: sorted(f.all_preperiodic_points())                                    # needs sage.rings.function_field
[(-2 : 1), (-1 : 1), (-1/2 : 1), (0 : 1), (1/2 : 1), (1 : 0), (1 : 1), (2 : 1)]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(3)*x*y])
>>> sorted(f.all_preperiodic_points())                                    # needs sage.rings.function_field
[(-2 : 1), (-1 : 1), (-1/2 : 1), (0 : 1), (1/2 : 1), (1 : 0), (1 : 1), (2 : 1)]

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([x^2 - y^2, 3*x*y])
sorted(f.all_preperiodic_points())                                    # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(1,QQ)
sage: f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
sage: sorted(f.all_preperiodic_points(prime_bound=10))                      # needs sage.rings.function_field
[(-1 : 1), (0 : 1), (1 : 0), (1 : 1), (3 : 1)]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(3) - Integer(53)*x*y**Integer(2) + Integer(24)*y**Integer(3), Integer(24)*y**Integer(3)])
>>> sorted(f.all_preperiodic_points(prime_bound=Integer(10)))                      # needs sage.rings.function_field
[(-1 : 1), (0 : 1), (1 : 0), (1 : 1), (3 : 1)]

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
sorted(f.all_preperiodic_points(prime_bound=10))                      # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(5)*x**Integer(3) - Integer(53)*x*y**Integer(2) + Integer(24)*y**Integer(3), Integer(24)*y**Integer(3)])
>>> sorted(f.all_preperiodic_points(prime_bound=Integer(10)))                      # needs sage.rings.function_field
[(-1 : 1), (0 : 1), (1 : 0), (1 : 1), (3 : 1)]

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([5*x^3 - 53*x*y^2 + 24*y^3, 24*y^3])
sorted(f.all_preperiodic_points(prime_bound=10))                      # needs sage.rings.function_field
sage: PS.<x,y,z> = ProjectiveSpace(2,QQ)
sage: f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sage: sorted(f.all_preperiodic_points(prime_bound=[1,8],              # long time
....:                                 lifting_prime=7, periods=[2]))
[(-5/4 : -2 : 1), (-5/4 : -1 : 1), (-5/4 : 0 : 1), (-5/4 : 1 : 1), (-5/4 : 2 : 1),
 (-1/4 : -2 : 1), (-1/4 : -1 : 1), (-1/4 : 0 : 1), (-1/4 : 1 : 1), (-1/4 : 2 : 1),
 (1/4 : -2 : 1), (1/4 : -1 : 1), (1/4 : 0 : 1), (1/4 : 1 : 1), (1/4 : 2 : 1),
 (5/4 : -2 : 1), (5/4 : -1 : 1), (5/4 : 0 : 1), (5/4 : 1 : 1), (5/4 : 2 : 1)]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> sorted(f.all_preperiodic_points(prime_bound=[Integer(1),Integer(8)],              # long time
...                                 lifting_prime=Integer(7), periods=[Integer(2)]))
[(-5/4 : -2 : 1), (-5/4 : -1 : 1), (-5/4 : 0 : 1), (-5/4 : 1 : 1), (-5/4 : 2 : 1),
 (-1/4 : -2 : 1), (-1/4 : -1 : 1), (-1/4 : 0 : 1), (-1/4 : 1 : 1), (-1/4 : 2 : 1),
 (1/4 : -2 : 1), (1/4 : -1 : 1), (1/4 : 0 : 1), (1/4 : 1 : 1), (1/4 : 2 : 1),
 (5/4 : -2 : 1), (5/4 : -1 : 1), (5/4 : 0 : 1), (5/4 : 1 : 1), (5/4 : 2 : 1)]

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sorted(f.all_preperiodic_points(prime_bound=[1,8],              # long time
                                lifting_prime=7, periods=[2]))
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> sorted(f.all_preperiodic_points(prime_bound=[Integer(1),Integer(8)],              # long time
...                                 lifting_prime=Integer(7), periods=[Integer(2)]))
[(-5/4 : -2 : 1), (-5/4 : -1 : 1), (-5/4 : 0 : 1), (-5/4 : 1 : 1), (-5/4 : 2 : 1),
 (-1/4 : -2 : 1), (-1/4 : -1 : 1), (-1/4 : 0 : 1), (-1/4 : 1 : 1), (-1/4 : 2 : 1),
 (1/4 : -2 : 1), (1/4 : -1 : 1), (1/4 : 0 : 1), (1/4 : 1 : 1), (1/4 : 2 : 1),
 (5/4 : -2 : 1), (5/4 : -1 : 1), (5/4 : 0 : 1), (5/4 : 1 : 1), (5/4 : 2 : 1)]

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sorted(f.all_preperiodic_points(prime_bound=[1,8],              # long time
                                lifting_prime=7, periods=[2]))
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(33)
sage: PS.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 - 71/48*y^2, y^2])
sage: sorted(f.all_preperiodic_points())    # long time
[(-1/12*w - 1 : 1),
 (-1/6*w - 1/4 : 1),
 (-1/12*w - 1/2 : 1),
 (-1/6*w + 1/4 : 1),
 (1/12*w - 1 : 1),
 (1/12*w - 1/2 : 1),
 (-1/12*w + 1/2 : 1),
 (-1/12*w + 1 : 1),
 (1/6*w - 1/4 : 1),
 (1/12*w + 1/2 : 1),
 (1 : 0),
 (1/6*w + 1/4 : 1),
 (1/12*w + 1 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(33), names=('w',)); (w,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(71)/Integer(48)*y**Integer(2), y**Integer(2)])
>>> sorted(f.all_preperiodic_points())    # long time
[(-1/12*w - 1 : 1),
 (-1/6*w - 1/4 : 1),
 (-1/12*w - 1/2 : 1),
 (-1/6*w + 1/4 : 1),
 (1/12*w - 1 : 1),
 (1/12*w - 1/2 : 1),
 (-1/12*w + 1/2 : 1),
 (-1/12*w + 1 : 1),
 (1/6*w - 1/4 : 1),
 (1/12*w + 1/2 : 1),
 (1 : 0),
 (1/6*w + 1/4 : 1),
 (1/12*w + 1 : 1)]

# needs sage.rings.number_field
K.<w> = QuadraticField(33)
PS.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 - 71/48*y^2, y^2])
sorted(f.all_preperiodic_points())    # long time
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(33), names=('w',)); (w,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(71)/Integer(48)*y**Integer(2), y**Integer(2)])
>>> sorted(f.all_preperiodic_points())    # long time
[(-1/12*w - 1 : 1),
 (-1/6*w - 1/4 : 1),
 (-1/12*w - 1/2 : 1),
 (-1/6*w + 1/4 : 1),
 (1/12*w - 1 : 1),
 (1/12*w - 1/2 : 1),
 (-1/12*w + 1/2 : 1),
 (-1/12*w + 1 : 1),
 (1/6*w - 1/4 : 1),
 (1/12*w + 1/2 : 1),
 (1 : 0),
 (1/6*w + 1/4 : 1),
 (1/12*w + 1 : 1)]

# needs sage.rings.number_field
K.<w> = QuadraticField(33)
PS.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 - 71/48*y^2, y^2])
sorted(f.all_preperiodic_points())    # long time
all_rational_preimages(points)[source]

Given a set of rational points in the domain of this dynamical system, return all the rational preimages of those points.

In others words, all the rational points which have some iterate in the set points. This function repeatedly calls rational_preimages(). If the degree is at least two, by Northocott, this is always a finite set. The map must be defined over number fields and be an endomorphism.

INPUT:

  • points – list of rational points in the domain of this map

OUTPUT: list of rational points in the domain of this map

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
sage: sorted(f.all_rational_preimages([P(-1,4)]))                           # needs sage.rings.function_field
[(-7/4 : 1), (-5/4 : 1), (-3/4 : 1), (-1/4 : 1), (1/4 : 1), (3/4 : 1),
 (5/4 : 1), (7/4 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(16)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(16)*y**Integer(2)])
>>> sorted(f.all_rational_preimages([P(-Integer(1),Integer(4))]))                           # needs sage.rings.function_field
[(-7/4 : 1), (-5/4 : 1), (-3/4 : 1), (-1/4 : 1), (1/4 : 1), (3/4 : 1),
 (5/4 : 1), (7/4 : 1)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
sorted(f.all_rational_preimages([P(-1,4)]))                           # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2 + 14*x*z
....:                                   + 45*y*z - 90*z^2,
....:                                 67*x^2 - 180*x*y - 157*x*z + 90*y*z,
....:                                 -90*z^2])
sage: sorted(f.all_rational_preimages([P(-9,-4,1)]))                        # needs sage.rings.function_field
[(-9 : -4 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1), (0 : 4 : 1),
 (1 : 0 : 1), (1 : 1 : 1), (1 : 2 : 1), (1 : 3 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(76)*x**Integer(2) - Integer(180)*x*y + Integer(45)*y**Integer(2) + Integer(14)*x*z
...                                   + Integer(45)*y*z - Integer(90)*z**Integer(2),
...                                 Integer(67)*x**Integer(2) - Integer(180)*x*y - Integer(157)*x*z + Integer(90)*y*z,
...                                 -Integer(90)*z**Integer(2)])
>>> sorted(f.all_rational_preimages([P(-Integer(9),-Integer(4),Integer(1))]))                        # needs sage.rings.function_field
[(-9 : -4 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1), (0 : 4 : 1),
 (1 : 0 : 1), (1 : 1 : 1), (1 : 2 : 1), (1 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2 + 14*x*z
                                  + 45*y*z - 90*z^2,
                                67*x^2 - 180*x*y - 157*x*z + 90*y*z,
                                -90*z^2])
sorted(f.all_rational_preimages([P(-9,-4,1)]))                        # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(76)*x**Integer(2) - Integer(180)*x*y + Integer(45)*y**Integer(2) + Integer(14)*x*z
...                                   + Integer(45)*y*z - Integer(90)*z**Integer(2),
...                                 Integer(67)*x**Integer(2) - Integer(180)*x*y - Integer(157)*x*z + Integer(90)*y*z,
...                                 -Integer(90)*z**Integer(2)])
>>> sorted(f.all_rational_preimages([P(-Integer(9),-Integer(4),Integer(1))]))                        # needs sage.rings.function_field
[(-9 : -4 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 1), (0 : 4 : 1),
 (1 : 0 : 1), (1 : 1 : 1), (1 : 2 : 1), (1 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(QQ,2)
f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2 + 14*x*z
                                  + 45*y*z - 90*z^2,
                                67*x^2 - 180*x*y - 157*x*z + 90*y*z,
                                -90*z^2])
sorted(f.all_rational_preimages([P(-9,-4,1)]))                        # needs sage.rings.function_field

A non-periodic example

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, 2*x*y])
sage: sorted(f.all_rational_preimages([P(17,15)]))                          # needs sage.rings.function_field
[(1/3 : 1), (3/5 : 1), (5/3 : 1), (3 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), Integer(2)*x*y])
>>> sorted(f.all_rational_preimages([P(Integer(17),Integer(15))]))                          # needs sage.rings.function_field
[(1/3 : 1), (3/5 : 1), (5/3 : 1), (3 : 1)]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 + y^2, 2*x*y])
sorted(f.all_rational_preimages([P(17,15)]))                          # needs sage.rings.function_field

A number field example:

sage: # needs sage.rings.number_field
sage: z = QQ['z'].0
sage: K.<w> = NumberField(z^3 + (z^2)/4 - (41/16)*z + 23/64)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
sage: sorted(f.all_rational_preimages([P(16*w^2 - 29, 16)]), key=str)
[(-w - 1/2 : 1),
 (-w : 1),
 (-w^2 + 21/16 : 1),
 (-w^2 + 29/16 : 1),
 (-w^2 - w + 25/16 : 1),
 (-w^2 - w + 33/16 : 1),
 (w + 1/2 : 1),
 (w : 1),
 (w^2 + w - 25/16 : 1),
 (w^2 + w - 33/16 : 1),
 (w^2 - 21/16 : 1),
 (w^2 - 29/16 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> z = QQ['z'].gen(0)
>>> K = NumberField(z**Integer(3) + (z**Integer(2))/Integer(4) - (Integer(41)/Integer(16))*z + Integer(23)/Integer(64), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(16)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(16)*y**Integer(2)])
>>> sorted(f.all_rational_preimages([P(Integer(16)*w**Integer(2) - Integer(29), Integer(16))]), key=str)
[(-w - 1/2 : 1),
 (-w : 1),
 (-w^2 + 21/16 : 1),
 (-w^2 + 29/16 : 1),
 (-w^2 - w + 25/16 : 1),
 (-w^2 - w + 33/16 : 1),
 (w + 1/2 : 1),
 (w : 1),
 (w^2 + w - 25/16 : 1),
 (w^2 + w - 33/16 : 1),
 (w^2 - 21/16 : 1),
 (w^2 - 29/16 : 1)]

# needs sage.rings.number_field
z = QQ['z'].0
K.<w> = NumberField(z^3 + (z^2)/4 - (41/16)*z + 23/64)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
sorted(f.all_rational_preimages([P(16*w^2 - 29, 16)]), key=str)
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(3)
sage: P.<u,v> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([u^2 + v^2, v^2])
sage: f.all_rational_preimages(P(4))                                        # needs sage.rings.function_field
[(-w : 1), (w : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), v**Integer(2)])
>>> f.all_rational_preimages(P(Integer(4)))                                        # needs sage.rings.function_field
[(-w : 1), (w : 1)]

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, v^2])
f.all_rational_preimages(P(4))                                        # needs sage.rings.function_field
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('u', 'v',)); (u, v,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([u**Integer(2) + v**Integer(2), v**Integer(2)])
>>> f.all_rational_preimages(P(Integer(4)))                                        # needs sage.rings.function_field
[(-w : 1), (w : 1)]

# needs sage.rings.number_field
K.<w> = QuadraticField(3)
P.<u,v> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([u^2 + v^2, v^2])
f.all_rational_preimages(P(4))                                        # needs sage.rings.function_field
conjugating_set(other, R=None, num_cpus=2)[source]

Return the set of elements in PGL over the base ring that conjugates one dynamical system to the other.

Given two nonconstant rational functions of equal degree, determine if there is a rational element of PGL that conjugates one rational function to another.

The optional argument \(R\) specifies the field of definition of the PGL elements. The set is determined by taking the fixed points of one map and mapping them to permutations of the fixed points of the other map. As conjugacy preserves the multipliers as a set, fixed points are only mapped to fixed points with the same multiplier. If there are not enough fixed points the function compares the mapping between rational preimages of fixed points and the rational preimages of the preimages of fixed points until there are enough points; such that there are \(n+2\) points with all \(n+1\) subsets linearly independent.

Warning

For degree 1 maps that are conjugate, there is a positive dimensional set of conjugations. This function returns only one such element.

ALGORITHM:

Implementing invariant set algorithm from the paper [FMV2014]. Uses the set of \(n\) th preimages of fixed points, as this set is invariant under conjugation to find all elements of PGL that take one set to another. Additionally, keeps track of multiplier information to reduce the necessary combinatorics.

INPUT:

  • other – a rational function of same degree as this map

  • R – a field or embedding

  • num_cpus – (default: 2) the number of threads to run in parallel; increasing num_cpus can potentially greatly speed up this function

OUTPUT: set of conjugating \(n+1\) by \(n+1\) matrices

AUTHORS:

  • Original algorithm written by Xander Faber, Michelle Manes, Bianca Viray [FMV2014].

  • Implemented by Rebecca Lauren Miller as part of GSOC 2016.

  • Algorithmic improvement by Alexander Galarraga as part of GSOC 2021.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: m = matrix(QQbar, 2, 2, [-1, 3, 2, 1])
sage: g = f.conjugate(m)
sage: f.conjugating_set(g)
[
[-1  3]
[ 2  1]
]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> m = matrix(QQbar, Integer(2), Integer(2), [-Integer(1), Integer(3), Integer(2), Integer(1)])
>>> g = f.conjugate(m)
>>> f.conjugating_set(g)
[
[-1  3]
[ 2  1]
]

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
m = matrix(QQbar, 2, 2, [-1, 3, 2, 1])
g = f.conjugate(m)
f.conjugating_set(g)

Increasing num_cpus can speed up computation:

sage: P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2, w^2])
sage: len(f.conjugating_set(f, num_cpus=3))                                 # needs sage.rings.function_field
24

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2), w**Integer(2)])
>>> len(f.conjugating_set(f, num_cpus=Integer(3)))                                 # needs sage.rings.function_field
24

P.<x,y,z,w> = ProjectiveSpace(QQ, 3)
f = DynamicalSystem_projective([x^2, y^2, z^2, w^2])
len(f.conjugating_set(f, num_cpus=3))                                 # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(-1)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: m = matrix(K, 2, 2, [1, 1, 2, 1])
sage: g = f.conjugate(m)
sage: sorted(f.conjugating_set(g))
[
[-1 -1]  [1 1]
[ 2  1], [2 1]
]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> m = matrix(K, Integer(2), Integer(2), [Integer(1), Integer(1), Integer(2), Integer(1)])
>>> g = f.conjugate(m)
>>> sorted(f.conjugating_set(g))
[
[-1 -1]  [1 1]
[ 2  1], [2 1]
]

# needs sage.rings.number_field
K.<w> = QuadraticField(-1)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
m = matrix(K, 2, 2, [1, 1, 2, 1])
g = f.conjugate(m)
sorted(f.conjugating_set(g))
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(1), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> m = matrix(K, Integer(2), Integer(2), [Integer(1), Integer(1), Integer(2), Integer(1)])
>>> g = f.conjugate(m)
>>> sorted(f.conjugating_set(g))
[
[-1 -1]  [1 1]
[ 2  1], [2 1]
]

# needs sage.rings.number_field
K.<w> = QuadraticField(-1)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
m = matrix(K, 2, 2, [1, 1, 2, 1])
g = f.conjugate(m)
sorted(f.conjugating_set(g))
sage: # needs sage.rings.number_field
sage: K.<i> = QuadraticField(-1)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: D8 = DynamicalSystem_projective([y^3, x^3])
sage: sorted(D8.conjugating_set(D8))
[
[-1  0]  [-i  0]  [ 0 -1]  [ 0 -i]  [0 i]  [0 1]  [i 0]  [1 0]
[ 0  1], [ 0  1], [ 1  0], [ 1  0], [1 0], [1 0], [0 1], [0 1]
]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(1), names=('i',)); (i,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D8 = DynamicalSystem_projective([y**Integer(3), x**Integer(3)])
>>> sorted(D8.conjugating_set(D8))
[
[-1  0]  [-i  0]  [ 0 -1]  [ 0 -i]  [0 i]  [0 1]  [i 0]  [1 0]
[ 0  1], [ 0  1], [ 1  0], [ 1  0], [1 0], [1 0], [0 1], [0 1]
]

# needs sage.rings.number_field
K.<i> = QuadraticField(-1)
P.<x,y> = ProjectiveSpace(K, 1)
D8 = DynamicalSystem_projective([y^3, x^3])
sorted(D8.conjugating_set(D8))
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(1), names=('i',)); (i,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D8 = DynamicalSystem_projective([y**Integer(3), x**Integer(3)])
>>> sorted(D8.conjugating_set(D8))
[
[-1  0]  [-i  0]  [ 0 -1]  [ 0 -i]  [0 i]  [0 1]  [i 0]  [1 0]
[ 0  1], [ 0  1], [ 1  0], [ 1  0], [1 0], [1 0], [0 1], [0 1]
]

# needs sage.rings.number_field
K.<i> = QuadraticField(-1)
P.<x,y> = ProjectiveSpace(K, 1)
D8 = DynamicalSystem_projective([y^3, x^3])
sorted(D8.conjugating_set(D8))
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: D8 = DynamicalSystem_projective([y^2, x^2])
sage: D8.conjugating_set(D8)                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no more rational preimages;
try extending the base field and trying again

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D8 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> D8.conjugating_set(D8)                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no more rational preimages;
try extending the base field and trying again

P.<x,y> = ProjectiveSpace(QQ, 1)
D8 = DynamicalSystem_projective([y^2, x^2])
D8.conjugating_set(D8)                                                # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D8 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> D8.conjugating_set(D8)                                                # needs sage.rings.function_field
Traceback (most recent call last):
...
ValueError: no more rational preimages;
try extending the base field and trying again

P.<x,y> = ProjectiveSpace(QQ, 1)
D8 = DynamicalSystem_projective([y^2, x^2])
D8.conjugating_set(D8)                                                # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(GF(7), 1)
sage: D6 = DynamicalSystem_projective([y^2, x^2])
sage: sorted(D6.conjugating_set(D6))                                        # needs sage.rings.function_field
[
[0 1]  [0 2]  [0 4]  [1 0]  [2 0]  [4 0]
[1 0], [1 0], [1 0], [0 1], [0 1], [0 1]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D6 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> sorted(D6.conjugating_set(D6))                                        # needs sage.rings.function_field
[
[0 1]  [0 2]  [0 4]  [1 0]  [2 0]  [4 0]
[1 0], [1 0], [1 0], [0 1], [0 1], [0 1]
]

P.<x,y> = ProjectiveSpace(GF(7), 1)
D6 = DynamicalSystem_projective([y^2, x^2])
sorted(D6.conjugating_set(D6))                                        # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D6 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> sorted(D6.conjugating_set(D6))                                        # needs sage.rings.function_field
[
[0 1]  [0 2]  [0 4]  [1 0]  [2 0]  [4 0]
[1 0], [1 0], [1 0], [0 1], [0 1], [0 1]
]

P.<x,y> = ProjectiveSpace(GF(7), 1)
D6 = DynamicalSystem_projective([y^2, x^2])
sorted(D6.conjugating_set(D6))                                        # needs sage.rings.function_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([x^2 + x*z, y^2, z^2])
sage: f.conjugating_set(f)                                                  # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*z, y**Integer(2), z**Integer(2)])
>>> f.conjugating_set(f)                                                  # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 + x*z, y^2, z^2])
f.conjugating_set(f)                                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*z, y**Integer(2), z**Integer(2)])
>>> f.conjugating_set(f)                                                  # needs sage.rings.function_field
[
[1 0 0]
[0 1 0]
[0 0 1]
]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([x^2 + x*z, y^2, z^2])
f.conjugating_set(f)                                                  # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: R = P.coordinate_ring()
sage: f = DynamicalSystem_projective([R(3), R(4)])
sage: g = DynamicalSystem_projective([R(5), R(2)])
sage: m = f.conjugating_set(g)[0]
sage: f.conjugate(m) == g
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> R = P.coordinate_ring()
>>> f = DynamicalSystem_projective([R(Integer(3)), R(Integer(4))])
>>> g = DynamicalSystem_projective([R(Integer(5)), R(Integer(2))])
>>> m = f.conjugating_set(g)[Integer(0)]
>>> f.conjugate(m) == g
True

P.<x,y> = ProjectiveSpace(QQ, 1)
R = P.coordinate_ring()
f = DynamicalSystem_projective([R(3), R(4)])
g = DynamicalSystem_projective([R(5), R(2)])
m = f.conjugating_set(g)[0]
f.conjugate(m) == g
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> R = P.coordinate_ring()
>>> f = DynamicalSystem_projective([R(Integer(3)), R(Integer(4))])
>>> g = DynamicalSystem_projective([R(Integer(5)), R(Integer(2))])
>>> m = f.conjugating_set(g)[Integer(0)]
>>> f.conjugate(m) == g
True

P.<x,y> = ProjectiveSpace(QQ, 1)
R = P.coordinate_ring()
f = DynamicalSystem_projective([R(3), R(4)])
g = DynamicalSystem_projective([R(5), R(2)])
m = f.conjugating_set(g)[0]
f.conjugate(m) == g
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([7*x + 12*y, 8*x])
sage: g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
sage: m = f.conjugating_set(g)[0]
sage: f.conjugate(m) == g
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*x])
>>> g = DynamicalSystem_projective([Integer(1645)*x - Integer(318)*y, Integer(8473)*x - Integer(1638)*y])
>>> m = f.conjugating_set(g)[Integer(0)]
>>> f.conjugate(m) == g
True

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([7*x + 12*y, 8*x])
g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
m = f.conjugating_set(g)[0]
f.conjugate(m) == g
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*x])
>>> g = DynamicalSystem_projective([Integer(1645)*x - Integer(318)*y, Integer(8473)*x - Integer(1638)*y])
>>> m = f.conjugating_set(g)[Integer(0)]
>>> f.conjugate(m) == g
True

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([7*x + 12*y, 8*x])
g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
m = f.conjugating_set(g)[0]
f.conjugate(m) == g

note that only one possible conjugation is returned:

sage: P.<x,y,z> = ProjectiveSpace(GF(11), 2)
sage: f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
sage: m1 = matrix(GF(11), 3, 3, [1,4,1,0,2,1,1,1,1])
sage: g = f.conjugate(m1)
sage: f.conjugating_set(g)
[
[ 1  0  0]
[ 9  1  4]
[ 4 10  8]
]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(11)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x + Integer(12)*y, Integer(11)*y + Integer(2)*z, x + z])
>>> m1 = matrix(GF(Integer(11)), Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.conjugating_set(g)
[
[ 1  0  0]
[ 9  1  4]
[ 4 10  8]
]

P.<x,y,z> = ProjectiveSpace(GF(11), 2)
f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
m1 = matrix(GF(11), 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.conjugating_set(g)
sage: # needs sage.rings.number_field
sage: L.<v> = CyclotomicField(8)
sage: P.<x,y,z> = ProjectiveSpace(L, 2)
sage: f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
sage: m1 = matrix(L, 3, 3, [1,4,v^2,0,2,1,1,1,1])
sage: g = f.conjugate(m1)
sage: m = f.conjugating_set(g)[0]   # long time
sage: f.conjugate(m) == g           # long time
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> L = CyclotomicField(Integer(8), names=('v',)); (v,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x + Integer(12)*y, Integer(11)*y + Integer(2)*z, x + z])
>>> m1 = matrix(L, Integer(3), Integer(3), [Integer(1),Integer(4),v**Integer(2),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> m = f.conjugating_set(g)[Integer(0)]   # long time
>>> f.conjugate(m) == g           # long time
True

# needs sage.rings.number_field
L.<v> = CyclotomicField(8)
P.<x,y,z> = ProjectiveSpace(L, 2)
f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
m1 = matrix(L, 3, 3, [1,4,v^2,0,2,1,1,1,1])
g = f.conjugate(m1)
m = f.conjugating_set(g)[0]   # long time
f.conjugate(m) == g           # long time
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> L = CyclotomicField(Integer(8), names=('v',)); (v,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x + Integer(12)*y, Integer(11)*y + Integer(2)*z, x + z])
>>> m1 = matrix(L, Integer(3), Integer(3), [Integer(1),Integer(4),v**Integer(2),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> m = f.conjugating_set(g)[Integer(0)]   # long time
>>> f.conjugate(m) == g           # long time
True

# needs sage.rings.number_field
L.<v> = CyclotomicField(8)
P.<x,y,z> = ProjectiveSpace(L, 2)
f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
m1 = matrix(L, 3, 3, [1,4,v^2,0,2,1,1,1,1])
g = f.conjugate(m1)
m = f.conjugating_set(g)[0]   # long time
f.conjugate(m) == g           # long time
connected_rational_component(P, n=0)[source]

Compute the connected component of a rational preperiodic point P by this dynamical system.

Will work for non-preperiodic points if n is positive. Otherwise this will not terminate.

INPUT:

  • P – a rational preperiodic point of this map

  • n – (default: 0) integer; maximum distance from P to branch out; a value of 0 indicates no bound

OUTPUT: list of points connected to P up to the specified distance

EXAMPLES:

sage: # needs sage.rings.number_field
sage: R.<x> = PolynomialRing(QQ)
sage: K.<w> = NumberField(x^3 + 1/4*x^2 - 41/16*x + 23/64)
sage: PS.<x,y> = ProjectiveSpace(1,K)
sage: f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
sage: P = PS([w,1])
sage: sorted(f.connected_rational_component(P), key=str)
[(-w - 1/2 : 1),
 (-w : 1),
 (-w^2 + 21/16 : 1),
 (-w^2 + 29/16 : 1),
 (-w^2 - w + 25/16 : 1),
 (-w^2 - w + 33/16 : 1),
 (w + 1/2 : 1),
 (w : 1),
 (w^2 + w - 25/16 : 1),
 (w^2 + w - 33/16 : 1),
 (w^2 - 21/16 : 1),
 (w^2 - 29/16 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = PolynomialRing(QQ, names=('x',)); (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(3) + Integer(1)/Integer(4)*x**Integer(2) - Integer(41)/Integer(16)*x + Integer(23)/Integer(64), names=('w',)); (w,) = K._first_ngens(1)
>>> PS = ProjectiveSpace(Integer(1),K, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(29)/Integer(16)*y**Integer(2), y**Integer(2)])
>>> P = PS([w,Integer(1)])
>>> sorted(f.connected_rational_component(P), key=str)
[(-w - 1/2 : 1),
 (-w : 1),
 (-w^2 + 21/16 : 1),
 (-w^2 + 29/16 : 1),
 (-w^2 - w + 25/16 : 1),
 (-w^2 - w + 33/16 : 1),
 (w + 1/2 : 1),
 (w : 1),
 (w^2 + w - 25/16 : 1),
 (w^2 + w - 33/16 : 1),
 (w^2 - 21/16 : 1),
 (w^2 - 29/16 : 1)]

# needs sage.rings.number_field
R.<x> = PolynomialRing(QQ)
K.<w> = NumberField(x^3 + 1/4*x^2 - 41/16*x + 23/64)
PS.<x,y> = ProjectiveSpace(1,K)
f = DynamicalSystem_projective([x^2 - 29/16*y^2, y^2])
P = PS([w,1])
sorted(f.connected_rational_component(P), key=str)
sage: PS.<x,y,z> = ProjectiveSpace(2,QQ)
sage: f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
sage: P = PS([17/16, 7/4, 1])
sage: f.connected_rational_component(P, 3)                                  # needs sage.rings.function_field
[(17/16 : 7/4 : 1),
 (-47/256 : 17/16 : 1),
 (-83807/65536 : -223/256 : 1),
 (-17/16 : -7/4 : 1),
 (-17/16 : 7/4 : 1),
 (17/16 : -7/4 : 1),
 (1386468673/4294967296 : -81343/65536 : 1),
 (-47/256 : -17/16 : 1),
 (47/256 : -17/16 : 1),
 (47/256 : 17/16 : 1),
 (-1/2 : -1/2 : 1),
 (-1/2 : 1/2 : 1),
 (1/2 : -1/2 : 1),
 (1/2 : 1/2 : 1)]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> P = PS([Integer(17)/Integer(16), Integer(7)/Integer(4), Integer(1)])
>>> f.connected_rational_component(P, Integer(3))                                  # needs sage.rings.function_field
[(17/16 : 7/4 : 1),
 (-47/256 : 17/16 : 1),
 (-83807/65536 : -223/256 : 1),
 (-17/16 : -7/4 : 1),
 (-17/16 : 7/4 : 1),
 (17/16 : -7/4 : 1),
 (1386468673/4294967296 : -81343/65536 : 1),
 (-47/256 : -17/16 : 1),
 (47/256 : -17/16 : 1),
 (47/256 : 17/16 : 1),
 (-1/2 : -1/2 : 1),
 (-1/2 : 1/2 : 1),
 (1/2 : -1/2 : 1),
 (1/2 : 1/2 : 1)]

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
P = PS([17/16, 7/4, 1])
f.connected_rational_component(P, 3)                                  # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(21)/Integer(16)*z**Integer(2), y**Integer(2) - Integer(2)*z**Integer(2), z**Integer(2)])
>>> P = PS([Integer(17)/Integer(16), Integer(7)/Integer(4), Integer(1)])
>>> f.connected_rational_component(P, Integer(3))                                  # needs sage.rings.function_field
[(17/16 : 7/4 : 1),
 (-47/256 : 17/16 : 1),
 (-83807/65536 : -223/256 : 1),
 (-17/16 : -7/4 : 1),
 (-17/16 : 7/4 : 1),
 (17/16 : -7/4 : 1),
 (1386468673/4294967296 : -81343/65536 : 1),
 (-47/256 : -17/16 : 1),
 (47/256 : -17/16 : 1),
 (47/256 : 17/16 : 1),
 (-1/2 : -1/2 : 1),
 (-1/2 : 1/2 : 1),
 (1/2 : -1/2 : 1),
 (1/2 : 1/2 : 1)]

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([x^2 - 21/16*z^2, y^2 - 2*z^2, z^2])
P = PS([17/16, 7/4, 1])
f.connected_rational_component(P, 3)                                  # needs sage.rings.function_field
is_conjugate(other, R=None, num_cpus=2)[source]

Return whether two dynamical systems are conjugate over their base ring (by default) or over the ring \(R\) entered as an optional parameter.

ALGORITHM:

Implementing invariant set algorithm from the paper [FMV2014]. Uses the set of \(n\) th preimages of fixed points, as this set is invariant under conjugation to find all elements of PGL that take one set to another. Additionally, keeps track of multiplier information to reduce the necessary combinatorics.

INPUT:

  • other – a nonconstant rational function of the same degree as this map

  • R – a field or embedding

  • num_cpus – (default: 2) the number of threads to run in parallel; increasing num_cpus can potentially greatly speed up this function

OUTPUT: boolean

AUTHORS:

  • Original algorithm written by Xander Faber, Michelle Manes, Bianca Viray [FMV2014].

  • Implemented by Rebecca Lauren Miller as part of GSOC 2016.

  • Algorithmic improvement by Alexander Galarraga as part of GSOC 2021.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: K.<w> = CyclotomicField(3)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: D8 = DynamicalSystem_projective([y^2, x^2])
sage: D8.is_conjugate(D8)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> D8 = DynamicalSystem_projective([y**Integer(2), x**Integer(2)])
>>> D8.is_conjugate(D8)
True

# needs sage.rings.number_field
K.<w> = CyclotomicField(3)
P.<x,y> = ProjectiveSpace(K, 1)
D8 = DynamicalSystem_projective([y^2, x^2])
D8.is_conjugate(D8)

We can speed up computation by increasing num_cpus:

sage: P.<x,y,z,w> = ProjectiveSpace(QQ,3)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2, w^2])
sage: f.is_conjugate(f, num_cpus=2)                                         # needs sage.rings.function_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(3), names=('x', 'y', 'z', 'w',)); (x, y, z, w,) = P._first_ngens(4)
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2), w**Integer(2)])
>>> f.is_conjugate(f, num_cpus=Integer(2))                                         # needs sage.rings.function_field
True

P.<x,y,z,w> = ProjectiveSpace(QQ,3)
f = DynamicalSystem_projective([x^2, y^2, z^2, w^2])
f.is_conjugate(f, num_cpus=2)                                         # needs sage.rings.function_field
sage: # needs sage.rings.number_field
sage: set_verbose(None)
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y, y^2])
sage: m = matrix(QQbar, 2, 2, [1, 1, 2, 1])
sage: g = f.conjugate(m)
sage: f.is_conjugate(g)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> m = matrix(QQbar, Integer(2), Integer(2), [Integer(1), Integer(1), Integer(2), Integer(1)])
>>> g = f.conjugate(m)
>>> f.is_conjugate(g)
True

# needs sage.rings.number_field
set_verbose(None)
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
m = matrix(QQbar, 2, 2, [1, 1, 2, 1])
g = f.conjugate(m)
f.is_conjugate(g)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> set_verbose(None)
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> m = matrix(QQbar, Integer(2), Integer(2), [Integer(1), Integer(1), Integer(2), Integer(1)])
>>> g = f.conjugate(m)
>>> f.is_conjugate(g)
True

# needs sage.rings.number_field
set_verbose(None)
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
m = matrix(QQbar, 2, 2, [1, 1, 2, 1])
g = f.conjugate(m)
f.is_conjugate(g)
sage: P.<x,y> = ProjectiveSpace(GF(5), 1)
sage: f = DynamicalSystem_projective([x^3 + x*y^2, y^3])
sage: m = matrix(GF(5), 2, 2, [1, 3, 2, 9])
sage: g = f.conjugate(m)
sage: f.is_conjugate(g)                                                     # needs sage.rings.number_field
True

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + x*y**Integer(2), y**Integer(3)])
>>> m = matrix(GF(Integer(5)), Integer(2), Integer(2), [Integer(1), Integer(3), Integer(2), Integer(9)])
>>> g = f.conjugate(m)
>>> f.is_conjugate(g)                                                     # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(GF(5), 1)
f = DynamicalSystem_projective([x^3 + x*y^2, y^3])
m = matrix(GF(5), 2, 2, [1, 3, 2, 9])
g = f.conjugate(m)
f.is_conjugate(g)                                                     # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + x*y**Integer(2), y**Integer(3)])
>>> m = matrix(GF(Integer(5)), Integer(2), Integer(2), [Integer(1), Integer(3), Integer(2), Integer(9)])
>>> g = f.conjugate(m)
>>> f.is_conjugate(g)                                                     # needs sage.rings.number_field
True

P.<x,y> = ProjectiveSpace(GF(5), 1)
f = DynamicalSystem_projective([x^3 + x*y^2, y^3])
m = matrix(GF(5), 2, 2, [1, 3, 2, 9])
g = f.conjugate(m)
f.is_conjugate(g)                                                     # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y, y^2])
sage: g = DynamicalSystem_projective([x^3 + x^2*y, y^3])
sage: f.is_conjugate(g)
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(3) + x**Integer(2)*y, y**Integer(3)])
>>> f.is_conjugate(g)
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
g = DynamicalSystem_projective([x^3 + x^2*y, y^3])
f.is_conjugate(g)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(3) + x**Integer(2)*y, y**Integer(3)])
>>> f.is_conjugate(g)
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
g = DynamicalSystem_projective([x^3 + x^2*y, y^3])
f.is_conjugate(g)
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + x*y, y^2])
sage: g = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: f.is_conjugate(g)                                                     # needs sage.rings.number_field
False

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.is_conjugate(g)                                                     # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
g = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.is_conjugate(g)                                                     # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + x*y, y**Integer(2)])
>>> g = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.is_conjugate(g)                                                     # needs sage.rings.number_field
False

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + x*y, y^2])
g = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.is_conjugate(g)                                                     # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQbar, 1)
sage: f = DynamicalSystem_projective([7*x + 12*y, 8*x])
sage: g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
sage: f.is_conjugate(g)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*x])
>>> g = DynamicalSystem_projective([Integer(1645)*x - Integer(318)*y, Integer(8473)*x - Integer(1638)*y])
>>> f.is_conjugate(g)
True

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([7*x + 12*y, 8*x])
g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
f.is_conjugate(g)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQbar, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*x])
>>> g = DynamicalSystem_projective([Integer(1645)*x - Integer(318)*y, Integer(8473)*x - Integer(1638)*y])
>>> f.is_conjugate(g)
True

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQbar, 1)
f = DynamicalSystem_projective([7*x + 12*y, 8*x])
g = DynamicalSystem_projective([1645*x - 318*y, 8473*x - 1638*y])
f.is_conjugate(g)

Conjugation is only checked over the base field by default:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([-3*y^2, 3*x^2])
sage: g = DynamicalSystem_projective([-x^2 - 2*x*y, 2*x*y + y^2])
sage: f.is_conjugate(g), f.is_conjugate(g, R=QQbar)                         # needs sage.rings.number_field
(False, True)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(3)*y**Integer(2), Integer(3)*x**Integer(2)])
>>> g = DynamicalSystem_projective([-x**Integer(2) - Integer(2)*x*y, Integer(2)*x*y + y**Integer(2)])
>>> f.is_conjugate(g), f.is_conjugate(g, R=QQbar)                         # needs sage.rings.number_field
(False, True)

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([-3*y^2, 3*x^2])
g = DynamicalSystem_projective([-x^2 - 2*x*y, 2*x*y + y^2])
f.is_conjugate(g), f.is_conjugate(g, R=QQbar)                         # needs sage.rings.number_field
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([7*x + 12*y, 8*y + 2*z, x + z])
sage: m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
sage: g = f.conjugate(m1)
sage: f.is_conjugate(g)
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*y + Integer(2)*z, x + z])
>>> m1 = matrix(QQ, Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([7*x + 12*y, 8*y + 2*z, x + z])
m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(7)*x + Integer(12)*y, Integer(8)*y + Integer(2)*z, x + z])
>>> m1 = matrix(QQ, Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([7*x + 12*y, 8*y + 2*z, x + z])
m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
sage: P.<x,y,z> = ProjectiveSpace(GF(7), 2)
sage: f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
sage: m1 = matrix(GF(7), 3, 3, [1,4,1,0,2,1,1,1,1])
sage: g = f.conjugate(m1)
sage: f.is_conjugate(g)
True

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x + Integer(12)*y, Integer(11)*y + Integer(2)*z, x + z])
>>> m1 = matrix(GF(Integer(7)), Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(GF(7), 2)
f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
m1 = matrix(GF(7), 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x + Integer(12)*y, Integer(11)*y + Integer(2)*z, x + z])
>>> m1 = matrix(GF(Integer(7)), Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(GF(7), 2)
f = DynamicalSystem_projective([2*x + 12*y, 11*y + 2*z, x + z])
m1 = matrix(GF(7), 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([2*x^2 + 12*y*x, 11*y*x + 2*y^2, x^2 + z^2])
sage: m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
sage: g = f.conjugate(m1)
sage: f.is_conjugate(g)
True

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) + Integer(12)*y*x, Integer(11)*y*x + Integer(2)*y**Integer(2), x**Integer(2) + z**Integer(2)])
>>> m1 = matrix(QQ, Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([2*x^2 + 12*y*x, 11*y*x + 2*y^2, x^2 + z^2])
m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(2) + Integer(12)*y*x, Integer(11)*y*x + Integer(2)*y**Integer(2), x**Integer(2) + z**Integer(2)])
>>> m1 = matrix(QQ, Integer(3), Integer(3), [Integer(1),Integer(4),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(1),Integer(1)])
>>> g = f.conjugate(m1)
>>> f.is_conjugate(g)
True

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([2*x^2 + 12*y*x, 11*y*x + 2*y^2, x^2 + z^2])
m1 = matrix(QQ, 3, 3, [1,4,1,0,2,1,1,1,1])
g = f.conjugate(m1)
f.is_conjugate(g)
is_newton(return_conjugation=False)[source]

Return whether self is a Newton map.

A map \(g\) is Newton if it is conjugate to a map of the form \(f(z) = z - \frac{p(z)}{p'(z)}\) after dehomogenization, where \(p(z)\) is a squarefree polynomial.

INPUT:

  • return_conjugation – boolean (default: False); if the map is Newton and True, then return the conjugation that moves this map to the above form

OUTPUT:

A boolean. If return_conjugation is True, then this also returns the conjugation as a matrix if self is Newton or None otherwise.

The conjugation may be defined over an extension if the map has fixed points not defined over the base field.

EXAMPLES:

sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem_affine([z - (z^2 + 1)/(2*z)])
sage: F = f.homogenize(1)
sage: F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
(
      [1 0]
True, [0 1]
)

>>> from sage.all import *
>>> A = AffineSpace(QQ, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([z - (z**Integer(2) + Integer(1))/(Integer(2)*z)])
>>> F = f.homogenize(Integer(1))
>>> F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
(
      [1 0]
True, [0 1]
)

A.<z> = AffineSpace(QQ, 1)
f = DynamicalSystem_affine([z - (z^2 + 1)/(2*z)])
F = f.homogenize(1)
F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
sage: A.<z> = AffineSpace(QQ, 1)
sage: f = DynamicalSystem_affine([z^2 + 1])
sage: F = f.homogenize(1)
sage: F.is_newton()                                                         # needs sage.rings.number_field
False
sage: F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
(False, None)

>>> from sage.all import *
>>> A = AffineSpace(QQ, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([z**Integer(2) + Integer(1)])
>>> F = f.homogenize(Integer(1))
>>> F.is_newton()                                                         # needs sage.rings.number_field
False
>>> F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
(False, None)

A.<z> = AffineSpace(QQ, 1)
f = DynamicalSystem_affine([z^2 + 1])
F = f.homogenize(1)
F.is_newton()                                                         # needs sage.rings.number_field
F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
>>> from sage.all import *
>>> A = AffineSpace(QQ, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine([z**Integer(2) + Integer(1)])
>>> F = f.homogenize(Integer(1))
>>> F.is_newton()                                                         # needs sage.rings.number_field
False
>>> F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
(False, None)

A.<z> = AffineSpace(QQ, 1)
f = DynamicalSystem_affine([z^2 + 1])
F = f.homogenize(1)
F.is_newton()                                                         # needs sage.rings.number_field
F.is_newton(return_conjugation=True)                                  # needs sage.rings.number_field
sage: PP.<x,y> = ProjectiveSpace(QQ, 1)
sage: F = DynamicalSystem_projective([-4*x^3 - 3*x*y^2, -2*y^3])
sage: F.is_newton(return_conjugation=True)[1]                               # needs sage.rings.number_field
[   0    1]
[-4*a  2*a]

>>> from sage.all import *
>>> PP = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = PP._first_ngens(2)
>>> F = DynamicalSystem_projective([-Integer(4)*x**Integer(3) - Integer(3)*x*y**Integer(2), -Integer(2)*y**Integer(3)])
>>> F.is_newton(return_conjugation=True)[Integer(1)]                               # needs sage.rings.number_field
[   0    1]
[-4*a  2*a]

PP.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([-4*x^3 - 3*x*y^2, -2*y^3])
F.is_newton(return_conjugation=True)[1]                               # needs sage.rings.number_field
>>> from sage.all import *
>>> PP = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = PP._first_ngens(2)
>>> F = DynamicalSystem_projective([-Integer(4)*x**Integer(3) - Integer(3)*x*y**Integer(2), -Integer(2)*y**Integer(3)])
>>> F.is_newton(return_conjugation=True)[Integer(1)]                               # needs sage.rings.number_field
[   0    1]
[-4*a  2*a]

PP.<x,y> = ProjectiveSpace(QQ, 1)
F = DynamicalSystem_projective([-4*x^3 - 3*x*y^2, -2*y^3])
F.is_newton(return_conjugation=True)[1]                               # needs sage.rings.number_field
sage: # needs sage.rings.number_field
sage: K.<zeta> = CyclotomicField(2*4)
sage: A.<z> = AffineSpace(K, 1)
sage: f = DynamicalSystem_affine(z-(z^3+zeta*z)/(3*z^2+zeta))
sage: F = f.homogenize(1)
sage: F.is_newton()
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(2)*Integer(4), names=('zeta',)); (zeta,) = K._first_ngens(1)
>>> A = AffineSpace(K, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine(z-(z**Integer(3)+zeta*z)/(Integer(3)*z**Integer(2)+zeta))
>>> F = f.homogenize(Integer(1))
>>> F.is_newton()
True

# needs sage.rings.number_field
K.<zeta> = CyclotomicField(2*4)
A.<z> = AffineSpace(K, 1)
f = DynamicalSystem_affine(z-(z^3+zeta*z)/(3*z^2+zeta))
F = f.homogenize(1)
F.is_newton()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(2)*Integer(4), names=('zeta',)); (zeta,) = K._first_ngens(1)
>>> A = AffineSpace(K, Integer(1), names=('z',)); (z,) = A._first_ngens(1)
>>> f = DynamicalSystem_affine(z-(z**Integer(3)+zeta*z)/(Integer(3)*z**Integer(2)+zeta))
>>> F = f.homogenize(Integer(1))
>>> F.is_newton()
True

# needs sage.rings.number_field
K.<zeta> = CyclotomicField(2*4)
A.<z> = AffineSpace(K, 1)
f = DynamicalSystem_affine(z-(z^3+zeta*z)/(3*z^2+zeta))
F = f.homogenize(1)
F.is_newton()
is_polynomial()[source]

Check to see if the dynamical system has a totally ramified fixed point.

The function must be defined over an absolute number field or a finite field.

OUTPUT: boolean

EXAMPLES:

sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = QuadraticField(7)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x**2 + 2*x*y - 5*y**2, 2*x*y])
sage: f.is_polynomial()
False

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = QuadraticField(Integer(7), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(2)*x*y - Integer(5)*y**Integer(2), Integer(2)*x*y])
>>> f.is_polynomial()
False

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = QuadraticField(7)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x**2 + 2*x*y - 5*y**2, 2*x*y])
f.is_polynomial()
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = QuadraticField(7)
sage: P.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([x**2 - 7*x*y, 2*y**2])
sage: m = matrix(K, 2, 2, [w, 1, 0, 1])
sage: f = f.conjugate(m)
sage: f.is_polynomial()
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = QuadraticField(Integer(7), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(7)*x*y, Integer(2)*y**Integer(2)])
>>> m = matrix(K, Integer(2), Integer(2), [w, Integer(1), Integer(0), Integer(1)])
>>> f = f.conjugate(m)
>>> f.is_polynomial()
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = QuadraticField(7)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x**2 - 7*x*y, 2*y**2])
m = matrix(K, 2, 2, [w, 1, 0, 1])
f = f.conjugate(m)
f.is_polynomial()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = QuadraticField(Integer(7), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(7)*x*y, Integer(2)*y**Integer(2)])
>>> m = matrix(K, Integer(2), Integer(2), [w, Integer(1), Integer(0), Integer(1)])
>>> f = f.conjugate(m)
>>> f.is_polynomial()
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = QuadraticField(7)
P.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([x**2 - 7*x*y, 2*y**2])
m = matrix(K, 2, 2, [w, 1, 0, 1])
f = f.conjugate(m)
f.is_polynomial()
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(4/27)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x**3 + w*y^3, x*y**2])
sage: f.is_polynomial()
False

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(4)/Integer(27), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + w*y**Integer(3), x*y**Integer(2)])
>>> f.is_polynomial()
False

# needs sage.rings.number_field
K.<w> = QuadraticField(4/27)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x**3 + w*y^3, x*y**2])
f.is_polynomial()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(Integer(4)/Integer(27), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + w*y**Integer(3), x*y**Integer(2)])
>>> f.is_polynomial()
False

# needs sage.rings.number_field
K.<w> = QuadraticField(4/27)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x**3 + w*y^3, x*y**2])
f.is_polynomial()
sage: # needs sage.rings.finite_rings
sage: K = GF(3**2, prefix='w')
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x**2 + K.gen()*y**2, x*y])
sage: f.is_polynomial()
False

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> K = GF(Integer(3)**Integer(2), prefix='w')
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + K.gen()*y**Integer(2), x*y])
>>> f.is_polynomial()
False

# needs sage.rings.finite_rings
K = GF(3**2, prefix='w')
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x**2 + K.gen()*y**2, x*y])
f.is_polynomial()
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> K = GF(Integer(3)**Integer(2), prefix='w')
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + K.gen()*y**Integer(2), x*y])
>>> f.is_polynomial()
False

# needs sage.rings.finite_rings
K = GF(3**2, prefix='w')
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x**2 + K.gen()*y**2, x*y])
f.is_polynomial()
sage: PS.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
sage: f.is_polynomial()
False

>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y + Integer(42)*y**Integer(2)])
>>> f.is_polynomial()
False

PS.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
f.is_polynomial()
>>> from sage.all import *
>>> PS = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(6)*x**Integer(2) + Integer(12)*x*y + Integer(7)*y**Integer(2), Integer(12)*x*y + Integer(42)*y**Integer(2)])
>>> f.is_polynomial()
False

PS.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([6*x^2 + 12*x*y + 7*y^2, 12*x*y + 42*y^2])
f.is_polynomial()
lift_to_rational_periodic(points_modp, B=None)[source]

Given a list of points in projective space over \(\GF{p}\), determine if they lift to \(\QQ\)-rational periodic points.

The map must be an endomorphism of projective space defined over \(\QQ\).

ALGORITHM:

Use Hensel lifting to find a \(p\)-adic approximation for that rational point. The accuracy needed is determined by the height bound B. Then apply the LLL algorithm to determine if the lift corresponds to a rational point.

If the point is a point of high multiplicity (multiplier 1), the procedure can be very slow.

INPUT:

  • points_modp – list or tuple of pairs containing a point in projective space over \(\GF{p}\) and the possible period

  • B – (optional) a positive integer; the height bound for a rational preperiodic point

OUTPUT: list of projective points

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.lift_to_rational_periodic([[P(0,1).change_ring(GF(7)), 4]])         # needs sage.symbolic
[[(0 : 1), 2]]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.lift_to_rational_periodic([[P(Integer(0),Integer(1)).change_ring(GF(Integer(7))), Integer(4)]])         # needs sage.symbolic
[[(0 : 1), 2]]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.lift_to_rational_periodic([[P(0,1).change_ring(GF(7)), 4]])         # needs sage.symbolic

There may be multiple points in the lift.

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([-5*x^2 + 4*y^2, 4*x*y])
sage: f.lift_to_rational_periodic([[P(1,0).change_ring(GF(3)), 1]])  # long time
[[(1 : 0), 1], [(2/3 : 1), 1], [(-2/3 : 1), 1]]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(5)*x**Integer(2) + Integer(4)*y**Integer(2), Integer(4)*x*y])
>>> f.lift_to_rational_periodic([[P(Integer(1),Integer(0)).change_ring(GF(Integer(3))), Integer(1)]])  # long time
[[(1 : 0), 1], [(2/3 : 1), 1], [(-2/3 : 1), 1]]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([-5*x^2 + 4*y^2, 4*x*y])
f.lift_to_rational_periodic([[P(1,0).change_ring(GF(3)), 1]])  # long time
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
sage: f.lift_to_rational_periodic([[P(3,1).change_ring(GF(13)), 3]])        # needs sage.symbolic
[[(-1/4 : 1), 3]]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(16)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(16)*y**Integer(2)])
>>> f.lift_to_rational_periodic([[P(Integer(3),Integer(1)).change_ring(GF(Integer(13))), Integer(3)]])        # needs sage.symbolic
[[(-1/4 : 1), 3]]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
f.lift_to_rational_periodic([[P(3,1).change_ring(GF(13)), 3]])        # needs sage.symbolic
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(16)*x**Integer(2) - Integer(29)*y**Integer(2), Integer(16)*y**Integer(2)])
>>> f.lift_to_rational_periodic([[P(Integer(3),Integer(1)).change_ring(GF(Integer(13))), Integer(3)]])        # needs sage.symbolic
[[(-1/4 : 1), 3]]

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([16*x^2 - 29*y^2, 16*y^2])
f.lift_to_rational_periodic([[P(3,1).change_ring(GF(13)), 3]])        # needs sage.symbolic
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2
....:                                   + 14*x*z + 45*y*z - 90*z^2,
....:                                 67*x^2 - 180*x*y - 157*x*z + 90*y*z,
....:                                 -90*z^2])
sage: f.lift_to_rational_periodic([[P(14,19,1).change_ring(GF(23)), 9]])    # long time
[[(-9 : -4 : 1), 9]]

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(76)*x**Integer(2) - Integer(180)*x*y + Integer(45)*y**Integer(2)
...                                   + Integer(14)*x*z + Integer(45)*y*z - Integer(90)*z**Integer(2),
...                                 Integer(67)*x**Integer(2) - Integer(180)*x*y - Integer(157)*x*z + Integer(90)*y*z,
...                                 -Integer(90)*z**Integer(2)])
>>> f.lift_to_rational_periodic([[P(Integer(14),Integer(19),Integer(1)).change_ring(GF(Integer(23))), Integer(9)]])    # long time
[[(-9 : -4 : 1), 9]]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2
                                  + 14*x*z + 45*y*z - 90*z^2,
                                67*x^2 - 180*x*y - 157*x*z + 90*y*z,
                                -90*z^2])
f.lift_to_rational_periodic([[P(14,19,1).change_ring(GF(23)), 9]])    # long time
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(76)*x**Integer(2) - Integer(180)*x*y + Integer(45)*y**Integer(2)
...                                   + Integer(14)*x*z + Integer(45)*y*z - Integer(90)*z**Integer(2),
...                                 Integer(67)*x**Integer(2) - Integer(180)*x*y - Integer(157)*x*z + Integer(90)*y*z,
...                                 -Integer(90)*z**Integer(2)])
>>> f.lift_to_rational_periodic([[P(Integer(14),Integer(19),Integer(1)).change_ring(GF(Integer(23))), Integer(9)]])    # long time
[[(-9 : -4 : 1), 9]]

P.<x,y,z> = ProjectiveSpace(QQ, 2)
f = DynamicalSystem_projective([76*x^2 - 180*x*y + 45*y^2
                                  + 14*x*z + 45*y*z - 90*z^2,
                                67*x^2 - 180*x*y - 157*x*z + 90*y*z,
                                -90*z^2])
f.lift_to_rational_periodic([[P(14,19,1).change_ring(GF(23)), 9]])    # long time
normal_form(return_conjugation=False)[source]

Return a normal form in the moduli space of dynamical systems.

Currently implemented only for polynomials. The totally ramified fixed point is moved to infinity and the map is conjugated to the form \(x^n + a_{n-2} x^{n-2} + \cdots + a_{0}\). Note that for finite fields we can only remove the \((n-1)\)-st term when the characteristic does not divide \(n\).

INPUT:

  • return_conjugation – boolean (default: False); if True, then return the conjugation element of PGL along with the embedding into the new field

OUTPUT:

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: f = DynamicalSystem_projective([x^2 + 2*x*y - 5*x^2, 2*x*y])
sage: f.normal_form()
Traceback (most recent call last):
...
NotImplementedError: map is not a polynomial

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(2)*x*y - Integer(5)*x**Integer(2), Integer(2)*x*y])
>>> f.normal_form()
Traceback (most recent call last):
...
NotImplementedError: map is not a polynomial

P.<x,y> = ProjectiveSpace(QQ, 1)
f = DynamicalSystem_projective([x^2 + 2*x*y - 5*x^2, 2*x*y])
f.normal_form()
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<w> = NumberField(x^2 - 5)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + w*x*y, y^2])
sage: g,m,psi = f.normal_form(return_conjugation=True); m
[     1 -1/2*w]
[     0      1]
sage: f.change_ring(psi).conjugate(m) == g
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - Integer(5), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + w*x*y, y**Integer(2)])
>>> g,m,psi = f.normal_form(return_conjugation=True); m
[     1 -1/2*w]
[     0      1]
>>> f.change_ring(psi).conjugate(m) == g
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - 5)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + w*x*y, y^2])
g,m,psi = f.normal_form(return_conjugation=True); m
f.change_ring(psi).conjugate(m) == g
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) - Integer(5), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + w*x*y, y**Integer(2)])
>>> g,m,psi = f.normal_form(return_conjugation=True); m
[     1 -1/2*w]
[     0      1]
>>> f.change_ring(psi).conjugate(m) == g
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<w> = NumberField(x^2 - 5)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + w*x*y, y^2])
g,m,psi = f.normal_form(return_conjugation=True); m
f.change_ring(psi).conjugate(m) == g
sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: f = DynamicalSystem_projective([13*x^2 + 4*x*y + 3*y^2, 5*y^2])
sage: f.normal_form()                                                       # needs sage.libs.pari
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (5*x^2 + 9*y^2 : 5*y^2)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(13)*x**Integer(2) + Integer(4)*x*y + Integer(3)*y**Integer(2), Integer(5)*y**Integer(2)])
>>> f.normal_form()                                                       # needs sage.libs.pari
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (5*x^2 + 9*y^2 : 5*y^2)

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([13*x^2 + 4*x*y + 3*y^2, 5*y^2])
f.normal_form()                                                       # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(13)*x**Integer(2) + Integer(4)*x*y + Integer(3)*y**Integer(2), Integer(5)*y**Integer(2)])
>>> f.normal_form()                                                       # needs sage.libs.pari
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (5*x^2 + 9*y^2 : 5*y^2)

P.<x,y> = ProjectiveSpace(QQ,1)
f = DynamicalSystem_projective([13*x^2 + 4*x*y + 3*y^2, 5*y^2])
f.normal_form()                                                       # needs sage.libs.pari
sage: # needs sage.rings.finite_rings
sage: K = GF(3^3, prefix='w')
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^3 + 2*x^2*y + 2*x*y^2 + K.gen()*y^3, y^3])
sage: f.normal_form()
Dynamical System of Projective Space of dimension 1
 over Finite Field in w3 of size 3^3
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + x^2*y + x*y^2 + (-w3)*y^3 : y^3)

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> K = GF(Integer(3)**Integer(3), prefix='w')
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(2)*x**Integer(2)*y + Integer(2)*x*y**Integer(2) + K.gen()*y**Integer(3), y**Integer(3)])
>>> f.normal_form()
Dynamical System of Projective Space of dimension 1
 over Finite Field in w3 of size 3^3
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + x^2*y + x*y^2 + (-w3)*y^3 : y^3)

# needs sage.rings.finite_rings
K = GF(3^3, prefix='w')
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 + 2*x^2*y + 2*x*y^2 + K.gen()*y^3, y^3])
f.normal_form()
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> K = GF(Integer(3)**Integer(3), prefix='w')
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3) + Integer(2)*x**Integer(2)*y + Integer(2)*x*y**Integer(2) + K.gen()*y**Integer(3), y**Integer(3)])
>>> f.normal_form()
Dynamical System of Projective Space of dimension 1
 over Finite Field in w3 of size 3^3
  Defn: Defined on coordinates by sending (x : y) to
        (x^3 + x^2*y + x*y^2 + (-w3)*y^3 : y^3)

# needs sage.rings.finite_rings
K = GF(3^3, prefix='w')
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^3 + 2*x^2*y + 2*x*y^2 + K.gen()*y^3, y^3])
f.normal_form()
sage: P.<x,y> = ProjectiveSpace(GF(3),1)
sage: f = DynamicalSystem_projective([2*x**3 + x**2*y, y**3])
sage: g,m,psi = f.normal_form(return_conjugation=True); psi                 # needs sage.rings.finite_rings
Ring morphism:
  From: Finite Field of size 3
  To:   Finite Field in z2 of size 3^2
  Defn: 1 |--> 1

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) + x**Integer(2)*y, y**Integer(3)])
>>> g,m,psi = f.normal_form(return_conjugation=True); psi                 # needs sage.rings.finite_rings
Ring morphism:
  From: Finite Field of size 3
  To:   Finite Field in z2 of size 3^2
  Defn: 1 |--> 1

P.<x,y> = ProjectiveSpace(GF(3),1)
f = DynamicalSystem_projective([2*x**3 + x**2*y, y**3])
g,m,psi = f.normal_form(return_conjugation=True); psi                 # needs sage.rings.finite_rings
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) + x**Integer(2)*y, y**Integer(3)])
>>> g,m,psi = f.normal_form(return_conjugation=True); psi                 # needs sage.rings.finite_rings
Ring morphism:
  From: Finite Field of size 3
  To:   Finite Field in z2 of size 3^2
  Defn: 1 |--> 1

P.<x,y> = ProjectiveSpace(GF(3),1)
f = DynamicalSystem_projective([2*x**3 + x**2*y, y**3])
g,m,psi = f.normal_form(return_conjugation=True); psi                 # needs sage.rings.finite_rings

Fixes Issue #38012 by not forcing univariate polynomial to be univariate:

sage: R.<z> = PolynomialRing(QQ)
sage: f = DynamicalSystem_affine(z^2 + z + 1).homogenize(1)
sage: f.normal_form()
Dynamical System of Projective Space of dimension 1 over Rational Field
 Defn: Defined on coordinates by sending (x0 : x1) to
       (x0^2 + 5/4*x1^2 : x1^2)

>>> from sage.all import *
>>> R = PolynomialRing(QQ, names=('z',)); (z,) = R._first_ngens(1)
>>> f = DynamicalSystem_affine(z**Integer(2) + z + Integer(1)).homogenize(Integer(1))
>>> f.normal_form()
Dynamical System of Projective Space of dimension 1 over Rational Field
 Defn: Defined on coordinates by sending (x0 : x1) to
       (x0^2 + 5/4*x1^2 : x1^2)

R.<z> = PolynomialRing(QQ)
f = DynamicalSystem_affine(z^2 + z + 1).homogenize(1)
f.normal_form()
potential_good_reduction(prime, return_conjugation=False)[source]

Return True if this dynamical system has potential good reduction at prime.

A dynamical system has good reduction at prime if after the coefficients are reduced modulo prime the degree remains the same. A dynamical system \(f\) has \(\textit{potential}\) good reduction if there exists \(\phi \in PGL(n,\overline{K})\) such that \(\phi^{-1} \circ f \circ \phi\) has good reduction.

If this dynamical system \(f\) has potential good reduction at prime, a dynamical system \(g = \phi^{-1} \circ f \circ \phi\) which has good reduction at prime is returned.

This dynamical system must have as its domain \(\mathbb{P}^1(K)\), where \(K\) is a number field.

INPUT:

  • prime – a prime ideal of the field of definition of the fixed points of the map, or a prime number in \(\QQ\) if the field of definition of the fixed points is \(\QQ\).

  • return_conjugation – boolean (default: False); if set to True, the \(PGL_2\) map used to achieve good reduction will be returned

OUTPUT: a tuple:

  • The first element is: - False if this dynamical system does not have potential good reduction. - True if this dynamical system does have potential good reduction.

  • The second element is: - None if this dynamical system does not have potential good reduction. - A dynamical system with good reduction at prime otherwise.

  • If return_conjugation is True, then the tuple will have a third element, which is: - None if this dynamical system does not have potential good reduction. - The \(PGL_2\) map used to achieve good reduction otherwise.

EXAMPLES:

sage: # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: system = DynamicalSystem_projective([x^2 - y^2, 2*x*y])
sage: prime = system.field_of_definition_periodic(1).prime_above(2)
sage: new_system = system.potential_good_reduction(prime)[1]
sage: new_system
Dynamical System of Projective Space of dimension 1 over Number Field
 in a with defining polynomial x^2 + 1
  Defn: Defined on coordinates by sending (x : y) to
        ((-1/2*a)*x^2 + (-5/2*a)*y^2 : (-a)*x*y + y^2)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> system = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), Integer(2)*x*y])
>>> prime = system.field_of_definition_periodic(Integer(1)).prime_above(Integer(2))
>>> new_system = system.potential_good_reduction(prime)[Integer(1)]
>>> new_system
Dynamical System of Projective Space of dimension 1 over Number Field
 in a with defining polynomial x^2 + 1
  Defn: Defined on coordinates by sending (x : y) to
        ((-1/2*a)*x^2 + (-5/2*a)*y^2 : (-a)*x*y + y^2)

# needs sage.rings.number_field
P.<x,y> = ProjectiveSpace(QQ, 1)
system = DynamicalSystem_projective([x^2 - y^2, 2*x*y])
prime = system.field_of_definition_periodic(1).prime_above(2)
new_system = system.potential_good_reduction(prime)[1]
new_system

Note that this map has good reduction at 2:

sage: new_system.resultant()                                                # needs sage.rings.number_field
1

>>> from sage.all import *
>>> new_system.resultant()                                                # needs sage.rings.number_field
1

new_system.resultant()                                                # needs sage.rings.number_field

Using return_conjugation, we can get the conjugation that achieves good reduction:

sage: conj = system.potential_good_reduction(prime, True)[2]; conj          # needs sage.rings.number_field
[-1/2*a    1/2]
[     0      1]

>>> from sage.all import *
>>> conj = system.potential_good_reduction(prime, True)[Integer(2)]; conj          # needs sage.rings.number_field
[-1/2*a    1/2]
[     0      1]

conj = system.potential_good_reduction(prime, True)[2]; conj          # needs sage.rings.number_field

We can check that this conjugation achieves good reduction:

sage: system.conjugate(conj).resultant()                                    # needs sage.rings.number_field
1

>>> from sage.all import *
>>> system.conjugate(conj).resultant()                                    # needs sage.rings.number_field
1

system.conjugate(conj).resultant()                                    # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: system = DynamicalSystem_projective([3^4*x^3 + 3*x*y^2 + y^3, 3^6*y^3])
sage: prime = system.field_of_definition_periodic(1).prime_above(3)         # needs sage.rings.number_field
sage: system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> system = DynamicalSystem_projective([Integer(3)**Integer(4)*x**Integer(3) + Integer(3)*x*y**Integer(2) + y**Integer(3), Integer(3)**Integer(6)*y**Integer(3)])
>>> prime = system.field_of_definition_periodic(Integer(1)).prime_above(Integer(3))         # needs sage.rings.number_field
>>> system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

P.<x,y> = ProjectiveSpace(QQ, 1)
system = DynamicalSystem_projective([3^4*x^3 + 3*x*y^2 + y^3, 3^6*y^3])
prime = system.field_of_definition_periodic(1).prime_above(3)         # needs sage.rings.number_field
system.potential_good_reduction(prime)                                # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> system = DynamicalSystem_projective([Integer(3)**Integer(4)*x**Integer(3) + Integer(3)*x*y**Integer(2) + y**Integer(3), Integer(3)**Integer(6)*y**Integer(3)])
>>> prime = system.field_of_definition_periodic(Integer(1)).prime_above(Integer(3))         # needs sage.rings.number_field
>>> system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

P.<x,y> = ProjectiveSpace(QQ, 1)
system = DynamicalSystem_projective([3^4*x^3 + 3*x*y^2 + y^3, 3^6*y^3])
prime = system.field_of_definition_periodic(1).prime_above(3)         # needs sage.rings.number_field
system.potential_good_reduction(prime)                                # needs sage.rings.number_field
sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: system = DynamicalSystem_projective([x^5 - x*y^4, 5*y^5])
sage: prime = system.field_of_definition_periodic(1).prime_above(5)         # needs sage.rings.number_field
sage: system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> system = DynamicalSystem_projective([x**Integer(5) - x*y**Integer(4), Integer(5)*y**Integer(5)])
>>> prime = system.field_of_definition_periodic(Integer(1)).prime_above(Integer(5))         # needs sage.rings.number_field
>>> system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

P.<x,y> = ProjectiveSpace(QQ, 1)
system = DynamicalSystem_projective([x^5 - x*y^4, 5*y^5])
prime = system.field_of_definition_periodic(1).prime_above(5)         # needs sage.rings.number_field
system.potential_good_reduction(prime)                                # needs sage.rings.number_field
>>> from sage.all import *
>>> P = ProjectiveSpace(QQ, Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> system = DynamicalSystem_projective([x**Integer(5) - x*y**Integer(4), Integer(5)*y**Integer(5)])
>>> prime = system.field_of_definition_periodic(Integer(1)).prime_above(Integer(5))         # needs sage.rings.number_field
>>> system.potential_good_reduction(prime)                                # needs sage.rings.number_field
(False, None)

P.<x,y> = ProjectiveSpace(QQ, 1)
system = DynamicalSystem_projective([x^5 - x*y^4, 5*y^5])
prime = system.field_of_definition_periodic(1).prime_above(5)         # needs sage.rings.number_field
system.potential_good_reduction(prime)                                # needs sage.rings.number_field
rational_preperiodic_graph(**kwds)[source]

Determine the directed graph of the rational preperiodic points for this dynamical system.

The map must be defined over \(\QQ\) and be an endomorphism of projective space. If this map is a polynomial endomorphism of \(\mathbb{P}^1\), i.e. has a totally ramified fixed point, then the base ring can be an absolute number field. This is done by passing to the Weil restriction.

ALGORITHM:

  • Determines the list of possible periods.

  • Determines the rational periodic points from the possible periods.

  • Determines the rational preperiodic points from the rational periodic points by determining rational preimages.

INPUT: keyword arguments:

  • prime_bound – (default: [1, 20]) a pair (list or tuple) of positive integers that represent the limits of primes to use in the reduction step or an integer that represents the upper bound

  • lifting_prime – (default: 23) a prime integer; specifies modulo which prime to try and perform the lifting

  • periods – (optional) a list of positive integers that is the list of possible periods

  • bad_primes – (optional) a list or tuple of integer primes; the primes of bad reduction

  • ncpus – (default: all cpus) number of cpus to use in parallel

OUTPUT:

A digraph representing the orbits of the rational preperiodic points in projective space.

EXAMPLES:

sage: PS.<x,y> = ProjectiveSpace(1,QQ)
sage: f = DynamicalSystem_projective([7*x^2 - 28*y^2, 24*x*y])
sage: f.rational_preperiodic_graph()                                        # needs sage.rings.function_field
Looped digraph on 12 vertices

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(7)*x**Integer(2) - Integer(28)*y**Integer(2), Integer(24)*x*y])
>>> f.rational_preperiodic_graph()                                        # needs sage.rings.function_field
Looped digraph on 12 vertices

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([7*x^2 - 28*y^2, 24*x*y])
f.rational_preperiodic_graph()                                        # needs sage.rings.function_field
sage: PS.<x,y> = ProjectiveSpace(1,QQ)
sage: f = DynamicalSystem_projective([-3/2*x^3 + 19/6*x*y^2, y^3])
sage: f.rational_preperiodic_graph(prime_bound=[1,8])                       # needs sage.rings.function_field
Looped digraph on 12 vertices

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(3)/Integer(2)*x**Integer(3) + Integer(19)/Integer(6)*x*y**Integer(2), y**Integer(3)])
>>> f.rational_preperiodic_graph(prime_bound=[Integer(1),Integer(8)])                       # needs sage.rings.function_field
Looped digraph on 12 vertices

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([-3/2*x^3 + 19/6*x*y^2, y^3])
f.rational_preperiodic_graph(prime_bound=[1,8])                       # needs sage.rings.function_field
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(1),QQ, names=('x', 'y',)); (x, y,) = PS._first_ngens(2)
>>> f = DynamicalSystem_projective([-Integer(3)/Integer(2)*x**Integer(3) + Integer(19)/Integer(6)*x*y**Integer(2), y**Integer(3)])
>>> f.rational_preperiodic_graph(prime_bound=[Integer(1),Integer(8)])                       # needs sage.rings.function_field
Looped digraph on 12 vertices

PS.<x,y> = ProjectiveSpace(1,QQ)
f = DynamicalSystem_projective([-3/2*x^3 + 19/6*x*y^2, y^3])
f.rational_preperiodic_graph(prime_bound=[1,8])                       # needs sage.rings.function_field
sage: PS.<x,y,z> = ProjectiveSpace(2,QQ)
sage: f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
....:                                 5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
sage: f.rational_preperiodic_graph(prime_bound=[1,11],  # long time
....:                              lifting_prime=13)
Looped digraph on 30 vertices

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> f.rational_preperiodic_graph(prime_bound=[Integer(1),Integer(11)],  # long time
...                              lifting_prime=Integer(13))
Looped digraph on 30 vertices

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
f.rational_preperiodic_graph(prime_bound=[1,11],  # long time
                             lifting_prime=13)
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),QQ, names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([Integer(2)*x**Integer(3) - Integer(50)*x*z**Integer(2) + Integer(24)*z**Integer(3),
...                                 Integer(5)*y**Integer(3) - Integer(53)*y*z**Integer(2) + Integer(24)*z**Integer(3), Integer(24)*z**Integer(3)])
>>> f.rational_preperiodic_graph(prime_bound=[Integer(1),Integer(11)],  # long time
...                              lifting_prime=Integer(13))
Looped digraph on 30 vertices

PS.<x,y,z> = ProjectiveSpace(2,QQ)
f = DynamicalSystem_projective([2*x^3 - 50*x*z^2 + 24*z^3,
                                5*y^3 - 53*y*z^2 + 24*z^3, 24*z^3])
f.rational_preperiodic_graph(prime_bound=[1,11],  # long time
                             lifting_prime=13)
sage: # needs sage.rings.number_field
sage: K.<w> = QuadraticField(-3)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2])
sage: f.rational_preperiodic_graph()        # long time
Looped digraph on 5 vertices

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.rational_preperiodic_graph()        # long time
Looped digraph on 5 vertices

# needs sage.rings.number_field
K.<w> = QuadraticField(-3)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.rational_preperiodic_graph()        # long time
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = QuadraticField(-Integer(3), names=('w',)); (w,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2)])
>>> f.rational_preperiodic_graph()        # long time
Looped digraph on 5 vertices

# needs sage.rings.number_field
K.<w> = QuadraticField(-3)
P.<x,y> = ProjectiveSpace(K,1)
f = DynamicalSystem_projective([x^2 + y^2, y^2])
f.rational_preperiodic_graph()        # long time
reduce_base_field()[source]

Return this map defined over the field of definition of the coefficients.

The base field of the map could be strictly larger than the field where all of the coefficients are defined. This function reduces the base field to the minimal possible. This can be done when the base ring is a number field, QQbar, a finite field, or algebraic closure of a finite field.

OUTPUT: a dynamical system

EXAMPLES:

sage: # needs sage.rings.finite_rings
sage: K.<t> = GF(2^3)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2+z*y])
sage: f.reduce_base_field()
Dynamical System of Projective Space of dimension 2 over Finite Field of size 2
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + y^2 : y^2 : y*z + z^2)

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> K = GF(Integer(2)**Integer(3), names=('t',)); (t,) = K._first_ngens(1)
>>> P = ProjectiveSpace(K, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), z**Integer(2)+z*y])
>>> f.reduce_base_field()
Dynamical System of Projective Space of dimension 2 over Finite Field of size 2
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + y^2 : y^2 : y*z + z^2)

# needs sage.rings.finite_rings
K.<t> = GF(2^3)
P.<x,y,z> = ProjectiveSpace(K, 2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2+z*y])
f.reduce_base_field()
sage: # needs sage.rings.number_field sage.symbolic
sage: P.<x,y,z> = ProjectiveSpace(QQbar, 2)
sage: f = DynamicalSystem_projective([x^2 + QQbar(sqrt(3))*y^2,
....:                                 y^2, QQbar(sqrt(2))*z^2])
sage: f.reduce_base_field()
Dynamical System of Projective Space of dimension 2 over Number Field in a
 with defining polynomial y^4 - 4*y^2 + 1 with a = -0.5176380902050415?
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + (-a^2 + 2)*y^2 : y^2 : (a^3 - 3*a)*z^2)

>>> from sage.all import *
>>> # needs sage.rings.number_field sage.symbolic
>>> P = ProjectiveSpace(QQbar, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + QQbar(sqrt(Integer(3)))*y**Integer(2),
...                                 y**Integer(2), QQbar(sqrt(Integer(2)))*z**Integer(2)])
>>> f.reduce_base_field()
Dynamical System of Projective Space of dimension 2 over Number Field in a
 with defining polynomial y^4 - 4*y^2 + 1 with a = -0.5176380902050415?
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + (-a^2 + 2)*y^2 : y^2 : (a^3 - 3*a)*z^2)

# needs sage.rings.number_field sage.symbolic
P.<x,y,z> = ProjectiveSpace(QQbar, 2)
f = DynamicalSystem_projective([x^2 + QQbar(sqrt(3))*y^2,
                                y^2, QQbar(sqrt(2))*z^2])
f.reduce_base_field()
>>> from sage.all import *
>>> # needs sage.rings.number_field sage.symbolic
>>> P = ProjectiveSpace(QQbar, Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + QQbar(sqrt(Integer(3)))*y**Integer(2),
...                                 y**Integer(2), QQbar(sqrt(Integer(2)))*z**Integer(2)])
>>> f.reduce_base_field()
Dynamical System of Projective Space of dimension 2 over Number Field in a
 with defining polynomial y^4 - 4*y^2 + 1 with a = -0.5176380902050415?
  Defn: Defined on coordinates by sending (x : y : z) to
        (x^2 + (-a^2 + 2)*y^2 : y^2 : (a^3 - 3*a)*z^2)

# needs sage.rings.number_field sage.symbolic
P.<x,y,z> = ProjectiveSpace(QQbar, 2)
f = DynamicalSystem_projective([x^2 + QQbar(sqrt(3))*y^2,
                                y^2, QQbar(sqrt(2))*z^2])
f.reduce_base_field()
sage: # needs sage.rings.number_field
sage: R.<x> = QQ[]
sage: K.<v> = NumberField(x^3 - 2, embedding=(x^3 - 2).roots(ring=CC)[0][0])
sage: R.<x> = QQ[]
sage: L.<w> = NumberField(x^6 + 9*x^4 - 4*x^3 + 27*x^2 + 36*x + 31,
....:                     embedding=(x^6 + 9*x^4 - 4*x^3
....:                                 + 27*x^2 + 36*x + 31).roots(ring=CC)[0][0])
sage: P.<x,y> = ProjectiveSpace(L,1)
sage: f = DynamicalSystem([L(v)*x^2 + y^2, x*y])
sage: f.reduce_base_field().base_ring().is_isomorphic(K)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(3) - Integer(2), embedding=(x**Integer(3) - Integer(2)).roots(ring=CC)[Integer(0)][Integer(0)], names=('v',)); (v,) = K._first_ngens(1)
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> L = NumberField(x**Integer(6) + Integer(9)*x**Integer(4) - Integer(4)*x**Integer(3) + Integer(27)*x**Integer(2) + Integer(36)*x + Integer(31),
...                     embedding=(x**Integer(6) + Integer(9)*x**Integer(4) - Integer(4)*x**Integer(3)
...                                 + Integer(27)*x**Integer(2) + Integer(36)*x + Integer(31)).roots(ring=CC)[Integer(0)][Integer(0)], names=('w',)); (w,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([L(v)*x**Integer(2) + y**Integer(2), x*y])
>>> f.reduce_base_field().base_ring().is_isomorphic(K)
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<v> = NumberField(x^3 - 2, embedding=(x^3 - 2).roots(ring=CC)[0][0])
R.<x> = QQ[]
L.<w> = NumberField(x^6 + 9*x^4 - 4*x^3 + 27*x^2 + 36*x + 31,
                    embedding=(x^6 + 9*x^4 - 4*x^3
                                + 27*x^2 + 36*x + 31).roots(ring=CC)[0][0])
P.<x,y> = ProjectiveSpace(L,1)
f = DynamicalSystem([L(v)*x^2 + y^2, x*y])
f.reduce_base_field().base_ring().is_isomorphic(K)
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(3) - Integer(2), embedding=(x**Integer(3) - Integer(2)).roots(ring=CC)[Integer(0)][Integer(0)], names=('v',)); (v,) = K._first_ngens(1)
>>> R = QQ['x']; (x,) = R._first_ngens(1)
>>> L = NumberField(x**Integer(6) + Integer(9)*x**Integer(4) - Integer(4)*x**Integer(3) + Integer(27)*x**Integer(2) + Integer(36)*x + Integer(31),
...                     embedding=(x**Integer(6) + Integer(9)*x**Integer(4) - Integer(4)*x**Integer(3)
...                                 + Integer(27)*x**Integer(2) + Integer(36)*x + Integer(31)).roots(ring=CC)[Integer(0)][Integer(0)], names=('w',)); (w,) = L._first_ngens(1)
>>> P = ProjectiveSpace(L,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem([L(v)*x**Integer(2) + y**Integer(2), x*y])
>>> f.reduce_base_field().base_ring().is_isomorphic(K)
True

# needs sage.rings.number_field
R.<x> = QQ[]
K.<v> = NumberField(x^3 - 2, embedding=(x^3 - 2).roots(ring=CC)[0][0])
R.<x> = QQ[]
L.<w> = NumberField(x^6 + 9*x^4 - 4*x^3 + 27*x^2 + 36*x + 31,
                    embedding=(x^6 + 9*x^4 - 4*x^3
                                + 27*x^2 + 36*x + 31).roots(ring=CC)[0][0])
P.<x,y> = ProjectiveSpace(L,1)
f = DynamicalSystem([L(v)*x^2 + y^2, x*y])
f.reduce_base_field().base_ring().is_isomorphic(K)
sage: # needs sage.rings.number_field
sage: K.<v> = CyclotomicField(5)
sage: A.<x,y> = ProjectiveSpace(K, 1)
sage: f = DynamicalSystem_projective([3*x^2 + y^2, x*y])
sage: f.reduce_base_field()
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (3*x^2 + y^2 : x*y)

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> A = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2) + y**Integer(2), x*y])
>>> f.reduce_base_field()
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (3*x^2 + y^2 : x*y)

# needs sage.rings.number_field
K.<v> = CyclotomicField(5)
A.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([3*x^2 + y^2, x*y])
f.reduce_base_field()
>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> K = CyclotomicField(Integer(5), names=('v',)); (v,) = K._first_ngens(1)
>>> A = ProjectiveSpace(K, Integer(1), names=('x', 'y',)); (x, y,) = A._first_ngens(2)
>>> f = DynamicalSystem_projective([Integer(3)*x**Integer(2) + y**Integer(2), x*y])
>>> f.reduce_base_field()
Dynamical System of Projective Space of dimension 1 over Rational Field
  Defn: Defined on coordinates by sending (x : y) to
        (3*x^2 + y^2 : x*y)

# needs sage.rings.number_field
K.<v> = CyclotomicField(5)
A.<x,y> = ProjectiveSpace(K, 1)
f = DynamicalSystem_projective([3*x^2 + y^2, x*y])
f.reduce_base_field()
class sage.dynamics.arithmetic_dynamics.projective_ds.DynamicalSystem_projective_finite_field(polys, domain)[source]

Bases: DynamicalSystem_projective_field, SchemeMorphism_polynomial_projective_space_finite_field

all_periodic_points(**kwds)[source]

Return a list of all periodic points over a finite field.

INPUT: keyword arguments:

  • R – (default: base ring of dynamical system) the base ring over which the periodic points of the dynamical system are found

OUTPUT: list of elements which are periodic

EXAMPLES:

sage: # needs sage.rings.finite_rings
sage: P.<x,y> = ProjectiveSpace(GF(5^2),1)
sage: f = DynamicalSystem_projective([x^2 + y^2, x*y])
sage: f.all_periodic_points()
[(1 : 0), (z2 + 2 : 1), (4*z2 + 3 : 1)]

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(5)**Integer(2)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), x*y])
>>> f.all_periodic_points()
[(1 : 0), (z2 + 2 : 1), (4*z2 + 3 : 1)]

# needs sage.rings.finite_rings
P.<x,y> = ProjectiveSpace(GF(5^2),1)
f = DynamicalSystem_projective([x^2 + y^2, x*y])
f.all_periodic_points()
sage: P.<x,y,z> = ProjectiveSpace(GF(5),2)
sage: f = DynamicalSystem_projective([x^2 + y^2 + z^2, x*y + x*z, z^2])
sage: f.all_periodic_points()
[(1 : 0 : 0),
 (0 : 0 : 1),
 (1 : 0 : 1),
 (2 : 1 : 1),
 (1 : 4 : 1),
 (3 : 0 : 1),
 (0 : 3 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2) + z**Integer(2), x*y + x*z, z**Integer(2)])
>>> f.all_periodic_points()
[(1 : 0 : 0),
 (0 : 0 : 1),
 (1 : 0 : 1),
 (2 : 1 : 1),
 (1 : 4 : 1),
 (3 : 0 : 1),
 (0 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(GF(5),2)
f = DynamicalSystem_projective([x^2 + y^2 + z^2, x*y + x*z, z^2])
f.all_periodic_points()
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2) + z**Integer(2), x*y + x*z, z**Integer(2)])
>>> f.all_periodic_points()
[(1 : 0 : 0),
 (0 : 0 : 1),
 (1 : 0 : 1),
 (2 : 1 : 1),
 (1 : 4 : 1),
 (3 : 0 : 1),
 (0 : 3 : 1)]

P.<x,y,z> = ProjectiveSpace(GF(5),2)
f = DynamicalSystem_projective([x^2 + y^2 + z^2, x*y + x*z, z^2])
f.all_periodic_points()
sage: P.<x,y> = ProjectiveSpace(GF(3), 1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.all_periodic_points(R=GF(3^2, 't'))                                 # needs sage.rings.finite_rings
[(1 : 0), (0 : 1), (2 : 1), (t : 1), (2*t + 1 : 1)]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.all_periodic_points(R=GF(Integer(3)**Integer(2), 't'))                                 # needs sage.rings.finite_rings
[(1 : 0), (0 : 1), (2 : 1), (t : 1), (2*t + 1 : 1)]

P.<x,y> = ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.all_periodic_points(R=GF(3^2, 't'))                                 # needs sage.rings.finite_rings
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)), Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.all_periodic_points(R=GF(Integer(3)**Integer(2), 't'))                                 # needs sage.rings.finite_rings
[(1 : 0), (0 : 1), (2 : 1), (t : 1), (2*t + 1 : 1)]

P.<x,y> = ProjectiveSpace(GF(3), 1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.all_periodic_points(R=GF(3^2, 't'))                                 # needs sage.rings.finite_rings
automorphism_group(**kwds)[source]

Return the subgroup of \(PGL2\) that is the automorphism group of this dynamical system.

The automorphism group is the set of \(PGL2\) elements that fixed the map under conjugation.

For dimension 1, see [FMV2014] for the algorithm.

For dimension greater than 1, we compute the conjugating set of this dynamical system with itself.

INPUT:

The following keywords are used when the dimension of the domain is greater than 1:

  • num_cpus – (default: 2) the number of threads to use; setting to a larger number can greatly speed up this function

The following keywords are used when the dimension of the domain is 1:

  • absolute – boolean (default: False); if True, then return the absolute automorphism group and a field of definition

  • iso_type – boolean (default: False); if True, then return the isomorphism type of the automorphism group

  • return_functions – boolean (default: False); True returns elements as linear fractional transformations and False returns elements as \(PGL2\) matrices

OUTPUT: list of elements of the automorphism group

AUTHORS:

  • Original algorithm written by Xander Faber, Michelle Manes, Bianca Viray

  • Modified by Joao Alberto de Faria, Ben Hutz, Bianca Thompson

EXAMPLES:

sage: # needs sage.rings.finite_rings
sage: R.<x,y> = ProjectiveSpace(GF(7^3,'t'),1)
sage: f = DynamicalSystem_projective([x^2 - y^2, x*y])
sage: f.automorphism_group()
[
[1 0]  [6 0]
[0 1], [0 1]
]

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(7)**Integer(3),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x*y])
>>> f.automorphism_group()
[
[1 0]  [6 0]
[0 1], [0 1]
]

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(7^3,'t'),1)
f = DynamicalSystem_projective([x^2 - y^2, x*y])
f.automorphism_group()
sage: # needs sage.rings.finite_rings
sage: R.<x,y> = ProjectiveSpace(GF(3^2,'t'),1)
sage: f = DynamicalSystem_projective([x^3, y^3])
sage: lst, label = f.automorphism_group(return_functions=True,      # long time
....:                                   iso_type=True)
sage: sorted(lst, key=str), label                                   # long time
([(2*x + 1)/(x + 1),
  (2*x + 1)/x,
  (2*x + 2)/(x + 2),
  (2*x + 2)/x,
  (x + 1)/(x + 2),
  (x + 1)/x,
  (x + 2)/(x + 1),
  (x + 2)/x,
  1/(x + 1),
  1/(x + 2),
  1/x,
  2*x,
  2*x + 1,
  2*x + 2,
  2*x/(x + 1),
  2*x/(x + 2),
  2/(x + 1),
  2/(x + 2),
  2/x,
  x,
  x + 1,
  x + 2,
  x/(x + 1),
  x/(x + 2)],
 'PGL(2,3)')

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(3)**Integer(2),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> lst, label = f.automorphism_group(return_functions=True,      # long time
...                                   iso_type=True)
>>> sorted(lst, key=str), label                                   # long time
([(2*x + 1)/(x + 1),
  (2*x + 1)/x,
  (2*x + 2)/(x + 2),
  (2*x + 2)/x,
  (x + 1)/(x + 2),
  (x + 1)/x,
  (x + 2)/(x + 1),
  (x + 2)/x,
  1/(x + 1),
  1/(x + 2),
  1/x,
  2*x,
  2*x + 1,
  2*x + 2,
  2*x/(x + 1),
  2*x/(x + 2),
  2/(x + 1),
  2/(x + 2),
  2/x,
  x,
  x + 1,
  x + 2,
  x/(x + 1),
  x/(x + 2)],
 'PGL(2,3)')

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(3^2,'t'),1)
f = DynamicalSystem_projective([x^3, y^3])
lst, label = f.automorphism_group(return_functions=True,      # long time
                                  iso_type=True)
sorted(lst, key=str), label                                   # long time
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(3)**Integer(2),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(3), y**Integer(3)])
>>> lst, label = f.automorphism_group(return_functions=True,      # long time
...                                   iso_type=True)
>>> sorted(lst, key=str), label                                   # long time
([(2*x + 1)/(x + 1),
  (2*x + 1)/x,
  (2*x + 2)/(x + 2),
  (2*x + 2)/x,
  (x + 1)/(x + 2),
  (x + 1)/x,
  (x + 2)/(x + 1),
  (x + 2)/x,
  1/(x + 1),
  1/(x + 2),
  1/x,
  2*x,
  2*x + 1,
  2*x + 2,
  2*x/(x + 1),
  2*x/(x + 2),
  2/(x + 1),
  2/(x + 2),
  2/x,
  x,
  x + 1,
  x + 2,
  x/(x + 1),
  x/(x + 2)],
 'PGL(2,3)')

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(3^2,'t'),1)
f = DynamicalSystem_projective([x^3, y^3])
lst, label = f.automorphism_group(return_functions=True,      # long time
                                  iso_type=True)
sorted(lst, key=str), label                                   # long time
sage: # needs sage.rings.finite_rings
sage: R.<x,y> = ProjectiveSpace(GF(2^5,'t'),1)
sage: f = DynamicalSystem_projective([x^5, y^5])
sage: f.automorphism_group(return_functions=True, iso_type=True)
([x, 1/x], 'Cyclic of order 2')

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(2)**Integer(5),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5), y**Integer(5)])
>>> f.automorphism_group(return_functions=True, iso_type=True)
([x, 1/x], 'Cyclic of order 2')

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(2^5,'t'),1)
f = DynamicalSystem_projective([x^5, y^5])
f.automorphism_group(return_functions=True, iso_type=True)
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(2)**Integer(5),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(5), y**Integer(5)])
>>> f.automorphism_group(return_functions=True, iso_type=True)
([x, 1/x], 'Cyclic of order 2')

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(2^5,'t'),1)
f = DynamicalSystem_projective([x^5, y^5])
f.automorphism_group(return_functions=True, iso_type=True)
sage: # needs sage.rings.finite_rings
sage: R.<x,y> = ProjectiveSpace(GF(3^4,'t'),1)
sage: f = DynamicalSystem_projective([x^2 + 25*x*y + y^2, x*y + 3*y^2])
sage: f.automorphism_group(absolute=True)
[Univariate Polynomial Ring in w over Finite Field in b of size 3^4,
 [
 [1 0]
 [0 1]
 ]]

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(3)**Integer(4),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(25)*x*y + y**Integer(2), x*y + Integer(3)*y**Integer(2)])
>>> f.automorphism_group(absolute=True)
[Univariate Polynomial Ring in w over Finite Field in b of size 3^4,
 [
 [1 0]
 [0 1]
 ]]

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(3^4,'t'),1)
f = DynamicalSystem_projective([x^2 + 25*x*y + y^2, x*y + 3*y^2])
f.automorphism_group(absolute=True)
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = ProjectiveSpace(GF(Integer(3)**Integer(4),'t'),Integer(1), names=('x', 'y',)); (x, y,) = R._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) + Integer(25)*x*y + y**Integer(2), x*y + Integer(3)*y**Integer(2)])
>>> f.automorphism_group(absolute=True)
[Univariate Polynomial Ring in w over Finite Field in b of size 3^4,
 [
 [1 0]
 [0 1]
 ]]

# needs sage.rings.finite_rings
R.<x,y> = ProjectiveSpace(GF(3^4,'t'),1)
f = DynamicalSystem_projective([x^2 + 25*x*y + y^2, x*y + 3*y^2])
f.automorphism_group(absolute=True)
sage: R.<x,y,z> = ProjectiveSpace(GF(5), 2)
sage: f = DynamicalSystem_projective([x^3 + x*z^2, y^3 + y*z^2, z^3])
sage: all([f.conjugate(m) == f for m in f.automorphism_group()])            # needs sage.rings.function_field
True

>>> from sage.all import *
>>> R = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = R._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(3) + x*z**Integer(2), y**Integer(3) + y*z**Integer(2), z**Integer(3)])
>>> all([f.conjugate(m) == f for m in f.automorphism_group()])            # needs sage.rings.function_field
True

R.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^3 + x*z^2, y^3 + y*z^2, z^3])
all([f.conjugate(m) == f for m in f.automorphism_group()])            # needs sage.rings.function_field
>>> from sage.all import *
>>> R = ProjectiveSpace(GF(Integer(5)), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = R._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(3) + x*z**Integer(2), y**Integer(3) + y*z**Integer(2), z**Integer(3)])
>>> all([f.conjugate(m) == f for m in f.automorphism_group()])            # needs sage.rings.function_field
True

R.<x,y,z> = ProjectiveSpace(GF(5), 2)
f = DynamicalSystem_projective([x^3 + x*z^2, y^3 + y*z^2, z^3])
all([f.conjugate(m) == f for m in f.automorphism_group()])            # needs sage.rings.function_field
cyclegraph()[source]

Return the digraph of all orbits of this dynamical system.

Over a finite field this is a finite graph. For subscheme domains, only points on the subscheme whose image are also on the subscheme are in the digraph.

OUTPUT: a digraph

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(GF(13),1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 14 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 14 vertices

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
f.cyclegraph()                                                        # needs sage.graphs
sage: # needs sage.rings.finite_rings
sage: P.<x,y,z> = ProjectiveSpace(GF(3^2,'t'),2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z])
sage: f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 91 vertices

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(3)**Integer(2),'t'),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), z**Integer(2) + y*z])
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 91 vertices

# needs sage.rings.finite_rings
P.<x,y,z> = ProjectiveSpace(GF(3^2,'t'),2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z])
f.cyclegraph()                                                        # needs sage.graphs
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> P = ProjectiveSpace(GF(Integer(3)**Integer(2),'t'),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), z**Integer(2) + y*z])
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 91 vertices

# needs sage.rings.finite_rings
P.<x,y,z> = ProjectiveSpace(GF(3^2,'t'),2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z])
f.cyclegraph()                                                        # needs sage.graphs
sage: P.<x,y,z> = ProjectiveSpace(GF(7),2)
sage: X = P.subscheme(x^2 - y^2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
sage: f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 15 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 15 vertices

P.<x,y,z> = ProjectiveSpace(GF(7),2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.cyclegraph()                                                        # needs sage.graphs
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 15 vertices

P.<x,y,z> = ProjectiveSpace(GF(7),2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.cyclegraph()                                                        # needs sage.graphs
sage: P.<x,y,z> = ProjectiveSpace(GF(3),2)
sage: f = DynamicalSystem_projective([x*z - y^2, x^2 - y^2, y^2 - z^2])
sage: f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 13 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x*z - y**Integer(2), x**Integer(2) - y**Integer(2), y**Integer(2) - z**Integer(2)])
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 13 vertices

P.<x,y,z> = ProjectiveSpace(GF(3),2)
f = DynamicalSystem_projective([x*z - y^2, x^2 - y^2, y^2 - z^2])
f.cyclegraph()                                                        # needs sage.graphs
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x*z - y**Integer(2), x**Integer(2) - y**Integer(2), y**Integer(2) - z**Integer(2)])
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 13 vertices

P.<x,y,z> = ProjectiveSpace(GF(3),2)
f = DynamicalSystem_projective([x*z - y^2, x^2 - y^2, y^2 - z^2])
f.cyclegraph()                                                        # needs sage.graphs
sage: P.<x,y,z> = ProjectiveSpace(GF(3),2)
sage: X = P.subscheme([x - y])
sage: f = DynamicalSystem_projective([x^2 - y^2, x^2 - y^2, y^2 - z^2], domain=X)
sage: f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 4 vertices

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme([x - y])
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x**Integer(2) - y**Integer(2), y**Integer(2) - z**Integer(2)], domain=X)
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 4 vertices

P.<x,y,z> = ProjectiveSpace(GF(3),2)
X = P.subscheme([x - y])
f = DynamicalSystem_projective([x^2 - y^2, x^2 - y^2, y^2 - z^2], domain=X)
f.cyclegraph()                                                        # needs sage.graphs
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(3)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme([x - y])
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), x**Integer(2) - y**Integer(2), y**Integer(2) - z**Integer(2)], domain=X)
>>> f.cyclegraph()                                                        # needs sage.graphs
Looped digraph on 4 vertices

P.<x,y,z> = ProjectiveSpace(GF(3),2)
X = P.subscheme([x - y])
f = DynamicalSystem_projective([x^2 - y^2, x^2 - y^2, y^2 - z^2], domain=X)
f.cyclegraph()                                                        # needs sage.graphs
is_postcritically_finite(**kwds)[source]

Every point is postcritically finite in a finite field.

INPUT: None. kwds is to parallel the overridden function

OUTPUT: the boolean True

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(GF(5),2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z], domain=P)
sage: f.is_postcritically_finite()
True

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), z**Integer(2) + y*z], domain=P)
>>> f.is_postcritically_finite()
True

P.<x,y,z> = ProjectiveSpace(GF(5),2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z], domain=P)
f.is_postcritically_finite()
sage: P.<x,y> = ProjectiveSpace(GF(13),1)
sage: f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
sage: f.is_postcritically_finite(use_algebraic_closure=False)
True

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)
True

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(4) - x**Integer(2)*y**Integer(2) + y**Integer(4), y**Integer(4)])
>>> f.is_postcritically_finite(use_algebraic_closure=False)
True

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^4 - x^2*y^2 + y^4, y^4])
f.is_postcritically_finite(use_algebraic_closure=False)
orbit_structure(P)[source]

Return the pair (m,n), where m is the preperiod and n is the period of the point P by this dynamical system.

Every point is preperiodic over a finite field so every point will be preperiodic.

INPUT:

  • P – a point in the domain of this map

OUTPUT: a tuple (m,n) of integers

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(GF(5),2)
sage: f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z], domain=P)
sage: f.orbit_structure(P(2,1,2))
(0, 6)

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(5)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> f = DynamicalSystem_projective([x**Integer(2) + y**Integer(2), y**Integer(2), z**Integer(2) + y*z], domain=P)
>>> f.orbit_structure(P(Integer(2),Integer(1),Integer(2)))
(0, 6)

P.<x,y,z> = ProjectiveSpace(GF(5),2)
f = DynamicalSystem_projective([x^2 + y^2, y^2, z^2 + y*z], domain=P)
f.orbit_structure(P(2,1,2))
sage: P.<x,y,z> = ProjectiveSpace(GF(7),2)
sage: X = P.subscheme(x^2 - y^2)
sage: f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
sage: f.orbit_structure(X(1,1,2))                                           # needs sage.rings.function_field
(0, 2)

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.orbit_structure(X(Integer(1),Integer(1),Integer(2)))                                           # needs sage.rings.function_field
(0, 2)

P.<x,y,z> = ProjectiveSpace(GF(7),2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.orbit_structure(X(1,1,2))                                           # needs sage.rings.function_field
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(7)),Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)
>>> X = P.subscheme(x**Integer(2) - y**Integer(2))
>>> f = DynamicalSystem_projective([x**Integer(2), y**Integer(2), z**Integer(2)], domain=X)
>>> f.orbit_structure(X(Integer(1),Integer(1),Integer(2)))                                           # needs sage.rings.function_field
(0, 2)

P.<x,y,z> = ProjectiveSpace(GF(7),2)
X = P.subscheme(x^2 - y^2)
f = DynamicalSystem_projective([x^2, y^2, z^2], domain=X)
f.orbit_structure(X(1,1,2))                                           # needs sage.rings.function_field
sage: P.<x,y> = ProjectiveSpace(GF(13),1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
sage: f.orbit_structure(P(3,4))
(2, 3)

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit_structure(P(Integer(3),Integer(4)))
(2, 3)

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
f.orbit_structure(P(3,4))
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit_structure(P(Integer(3),Integer(4)))
(2, 3)

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
f.orbit_structure(P(3,4))
sage: # needs sage.rings.finite_rings
sage: R.<t> = GF(13^3)
sage: P.<x,y> = ProjectiveSpace(R,1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
sage: f.orbit_structure(P(t, 4))
(11, 6)

>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = GF(Integer(13)**Integer(3), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit_structure(P(t, Integer(4)))
(11, 6)

# needs sage.rings.finite_rings
R.<t> = GF(13^3)
P.<x,y> = ProjectiveSpace(R,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
f.orbit_structure(P(t, 4))
>>> from sage.all import *
>>> # needs sage.rings.finite_rings
>>> R = GF(Integer(13)**Integer(3), names=('t',)); (t,) = R._first_ngens(1)
>>> P = ProjectiveSpace(R,Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)], domain=P)
>>> f.orbit_structure(P(t, Integer(4)))
(11, 6)

# needs sage.rings.finite_rings
R.<t> = GF(13^3)
P.<x,y> = ProjectiveSpace(R,1)
f = DynamicalSystem_projective([x^2 - y^2, y^2], domain=P)
f.orbit_structure(P(t, 4))
possible_periods(return_points=False)[source]

Return the list of possible minimal periods of a periodic point over \(\QQ\) and (optionally) a point in each cycle.

ALGORITHM:

See [Hutz2009].

INPUT:

  • return_points – boolean (default: False); if True, then return the points as well as the possible periods

OUTPUT:

A list of positive integers, or a list of pairs of projective points and periods if return_points is True.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(GF(23),1)
sage: f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
sage: f.possible_periods()                                                  # needs sage.libs.pari
[1, 5, 11, 22, 110]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(23)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - Integer(2)*y**Integer(2), y**Integer(2)])
>>> f.possible_periods()                                                  # needs sage.libs.pari
[1, 5, 11, 22, 110]

P.<x,y> = ProjectiveSpace(GF(23),1)
f = DynamicalSystem_projective([x^2 - 2*y^2, y^2])
f.possible_periods()                                                  # needs sage.libs.pari
sage: P.<x,y> = ProjectiveSpace(GF(13),1)
sage: f = DynamicalSystem_projective([x^2 - y^2, y^2])
sage: sorted(f.possible_periods(True))                                      # needs sage.libs.pari
[[(0 : 1), 2], [(1 : 0), 1], [(3 : 1), 3], [(3 : 1), 36]]

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> sorted(f.possible_periods(True))                                      # needs sage.libs.pari
[[(0 : 1), 2], [(1 : 0), 1], [(3 : 1), 3], [(3 : 1), 36]]

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
sorted(f.possible_periods(True))                                      # needs sage.libs.pari
>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(13)),Integer(1), names=('x', 'y',)); (x, y,) = P._first_ngens(2)
>>> f = DynamicalSystem_projective([x**Integer(2) - y**Integer(2), y**Integer(2)])
>>> sorted(f.possible_periods(True))                                      # needs sage.libs.pari
[[(0 : 1), 2], [(1 : 0), 1], [(3 : 1), 3], [(3 : 1), 36]]

P.<x,y> = ProjectiveSpace(GF(13),1)
f = DynamicalSystem_projective([x^2 - y^2, y^2])
sorted(f.possible_periods(True))                                      # needs sage.libs.pari
sage: PS.<x,y,z> = ProjectiveSpace(2,GF(7))
sage: f = DynamicalSystem_projective([-360*x^3 + 760*x*z^2,
....:                                 y^3 - 604*y*z^2 + 240*z^3, 240*z^3])
sage: f.possible_periods()                                                  # needs sage.libs.pari
[1, 2, 4, 6, 12, 14, 28, 42, 84]

>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),GF(Integer(7)), names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([-Integer(360)*x**Integer(3) + Integer(760)*x*z**Integer(2),
...                                 y**Integer(3) - Integer(604)*y*z**Integer(2) + Integer(240)*z**Integer(3), Integer(240)*z**Integer(3)])
>>> f.possible_periods()                                                  # needs sage.libs.pari
[1, 2, 4, 6, 12, 14, 28, 42, 84]

PS.<x,y,z> = ProjectiveSpace(2,GF(7))
f = DynamicalSystem_projective([-360*x^3 + 760*x*z^2,
                                y^3 - 604*y*z^2 + 240*z^3, 240*z^3])
f.possible_periods()                                                  # needs sage.libs.pari
>>> from sage.all import *
>>> PS = ProjectiveSpace(Integer(2),GF(Integer(7)), names=('x', 'y', 'z',)); (x, y, z,) = PS._first_ngens(3)
>>> f = DynamicalSystem_projective([-Integer(360)*x**Integer(3) + Integer(760)*x*z**Integer(2),
...                                 y**Integer(3) - Integer(604)*y*z**Integer(2) + Integer(240)*z**Integer(3), Integer(240)*z**Integer(3)])
>>> f.possible_periods()                                                  # needs sage.libs.pari
[1, 2, 4, 6, 12, 14, 28, 42, 84]

PS.<x,y,z> = ProjectiveSpace(2,GF(7))
f = DynamicalSystem_projective([-360*x^3 + 760*x*z^2,
                                y^3 - 604*y*z^2 + 240*z^3, 240*z^3])
f.possible_periods()                                                  # needs sage.libs.pari

Todo

  • do not return duplicate points

  • improve hash to reduce memory of point-table