Points on projective varieties

Scheme morphism for points on projective varieties

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 (June 2012) added support for projective ring; (March 2013) iteration functionality and new directory structure for affine/projective, height functionality
class sage.schemes.projective.projective_point.SchemeMorphism_point_abelian_variety_field(X, v, check=True)

Bases: sage.structure.element.AdditiveGroupElement, sage.schemes.projective.projective_point.SchemeMorphism_point_projective_field

A rational point of an abelian variety over a field.

EXAMPLES:

sage: E = EllipticCurve([0,0,1,-1,0])
sage: origin = E(0)
sage: origin.domain()
Spectrum of Rational Field
sage: origin.codomain()
Elliptic Curve defined by y^2 + y = x^3 - x over Rational Field
class sage.schemes.projective.projective_point.SchemeMorphism_point_projective_field(X, v, check=True)

Bases: sage.schemes.projective.projective_point.SchemeMorphism_point_projective_ring

A rational point of projective space over a field.

INPUT:

  • X – a homset of a subscheme of an ambient projective space over a field \(K\)
  • v – a list or tuple of coordinates in \(K\)
  • check – boolean (optional, default:True). Whether to check the input for consistency.

EXAMPLES:

sage: P = ProjectiveSpace(3, RR)
sage: P(2,3,4,5)
(0.400000000000000 : 0.600000000000000 : 0.800000000000000 : 1.00000000000000)
clear_denominators()

scales by the least common multiple of the denominators.

OUTPUT: None.

EXAMPLES:

sage: R.<t> = PolynomialRing(QQ)
sage: P.<x,y,z> = ProjectiveSpace(FractionField(R), 2)
sage: Q = P([t, 3/t^2, 1])
sage: Q.clear_denominators(); Q
(t^3 : 3 : t^2)
sage: R.<x> = PolynomialRing(QQ)
sage: K.<w> = NumberField(x^2 - 3)
sage: P.<x,y,z> = ProjectiveSpace(K, 2)
sage: Q = P([1/w, 3, 0])
sage: Q.clear_denominators(); Q
(w : 9 : 0)
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: X = P.subscheme(x^2 - y^2);
sage: Q = X([1/2, 1/2, 1]);
sage: Q.clear_denominators(); Q
(1 : 1 : 2)
sage: PS.<x,y> = ProjectiveSpace(QQ, 1)
sage: Q = PS.point([1, 2/3], False); Q
(1 : 2/3)
sage: Q.clear_denominators(); Q
(3 : 2)
normalize_coordinates()

Normalizes self so that the last non-zero coordinate is \(1\).

OUTPUT: None.

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(GF(5),2)
sage: Q = P.point([GF(5)(1), GF(5)(3), GF(5)(0)], False); Q
(1 : 3 : 0)
sage: Q.normalize_coordinates(); Q
(2 : 1 : 0)
sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: X  =P.subscheme(x^2-y^2);
sage: Q = X.point([23, 23, 46], False); Q
(23 : 23 : 46)
sage: Q.normalize_coordinates(); Q
(1/2 : 1/2 : 1)
class sage.schemes.projective.projective_point.SchemeMorphism_point_projective_finite_field(X, v, check=True)

Bases: sage.schemes.projective.projective_point.SchemeMorphism_point_projective_field

The Python constructor.

See SchemeMorphism_point_projective_ring for details.

This function still normalized points so that the rightmost non-zero coordinate is 1. The is to maintain current functionality with current implementations of curves in projectives space (plane, connic, elliptic, etc). The class:\(SchemeMorphism_point_projective_ring\) is for general use.

EXAMPLES:

sage: P = ProjectiveSpace(2, QQ)
sage: P(2, 3/5, 4)
(1/2 : 3/20 : 1)
sage: P = ProjectiveSpace(3, QQ)
sage: P(0,0,0,0)
Traceback (most recent call last):
...
ValueError: [0, 0, 0, 0] does not define a valid point since all entries are 0
sage: P.<x, y, z> = ProjectiveSpace(2, QQ)
sage: X = P.subscheme([x^2-y*z])
sage: X([2,2,2])
(1 : 1 : 1)
sage: P = ProjectiveSpace(1, GF(7))
sage: Q=P([2, 1])
sage: Q[0].parent()
Finite Field of size 7
orbit_structure(f)

Every point is preperiodic over a finite field. This function returns the pair \([m,n]\) where \(m\) is the preperiod and \(n\) is the period of the point self by f.

INPUT:

  • f – a ScemeMorphism_polynomial with self in f.domain()

OUTPUT:

  • a list \([m,n]\) of integers

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(GF(5),2)
sage: H = Hom(P,P)
sage: f = H([x^2 + y^2,y^2,z^2 + y*z])
sage: P(1,0,1).orbit_structure(f)
[0, 1]
sage: P.<x,y,z> = ProjectiveSpace(GF(17),2)
sage: X = P.subscheme(x^2-y^2)
sage: H = Hom(X,X)
sage: f = H([x^2,y^2,z^2])
sage: X(1,1,2).orbit_structure(f)
[3, 1]
sage: R.<t> = GF(13^3)
sage: P.<x,y> = ProjectiveSpace(R,1)
sage: H = Hom(P,P)
sage: f = H([x^2 - y^2,y^2])
sage: P(t,4).orbit_structure(f)
[11, 6]
class sage.schemes.projective.projective_point.SchemeMorphism_point_projective_ring(X, v, check=True)

Bases: sage.schemes.generic.morphism.SchemeMorphism_point

A rational point of projective space over a ring.

INPUT:

  • X – a homset of a subscheme of an ambient projective space over a field \(K\)
  • v – a list or tuple of coordinates in \(K\)
  • check – boolean (optional, default:True). Whether to check the input for consistency.

EXAMPLES:

sage: P = ProjectiveSpace(2, ZZ)
sage: P(2,3,4)
(2 : 3 : 4)
canonical_height(F, **kwds)

Evaluates the (absolute) canonical height of self with respect to F. 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.

INPUT:

  • F - a projective morphism

kwds:

  • badprimes - a list of primes of bad reduction
  • N - positive integer. number of terms of the series to use in the local green functions
  • prec - positive integer, float point or p-adic precision
  • error_bound - a positive real number

OUTPUT:

  • a real number

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(ZZ,1)
sage: H = Hom(P,P)
sage: f = H([x^2+y^2,2*x*y]);
sage: Q = P(2,1)
sage: f.canonical_height(f(Q))
2.1965476757927038111992627081
sage: f.canonical_height(Q)
1.0979353871245941198040174712

Notice that preperiodic points may not be exactly 0.

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: H = Hom(P,P)
sage: f = H([x^2-29/16*y^2,y^2]);
sage: Q = P(5,4)
sage: f.canonical_height(Q, N=30)
1.4989058602918874235833076226e-9
sage: P.<x,y,z> = ProjectiveSpace(QQ,2)
sage: X = P.subscheme(x^2-y^2);
sage: H = Hom(X,X)
sage: f = H([x^2,y^2,30*z^2]);
sage: Q = X([4,4,1])
sage: f.canonical_height(Q, badprimes=[2,3,5], prec=200)
2.7054056208276961889784303469356774912979228770208655455481
dehomogenize(n)

Dehomogenizes at the nth coordinate

INPUT:

  • n – non-negative integer

OUTPUT:

  • SchemeMorphism_point_affine

EXAMPLES:

sage: P.<x,y,z>=ProjectiveSpace(QQ,2)
sage: X=P.subscheme(x^2-y^2);
sage: Q=X(23,23,46)
sage: Q.dehomogenize(2)
(1/2, 1/2)
sage: R.<t>=PolynomialRing(QQ)
sage: S=R.quo(R.ideal(t^3))
sage: P.<x,y,z>=ProjectiveSpace(S,2)
sage: Q=P(t,1,1)
sage: Q.dehomogenize(1)
(tbar, 1)
sage: P.<x,y,z>=ProjectiveSpace(GF(5),2)
sage: Q=P(1,3,1)
sage: Q.dehomogenize(0)
(3, 1)
sage: P.<x,y,z>=ProjectiveSpace(GF(5),2)
sage: Q=P(1,3,0)
sage: Q.dehomogenize(2)
Traceback (most recent call last):
...
ValueError: Can't dehomogenize at 0 coordinate.
global_height(prec=None)

Returns the logarithmic height of the points.

INPUT:

  • prec – desired floating point precision (default: default RealField precision).

OUTPUT:

  • a real number

EXAMPLES:

sage: P.<x,y,z>=ProjectiveSpace(QQ,2)
sage: Q=P.point([4,4,1/30])
sage: Q.global_height()
4.78749174278205
sage: P.<x,y,z>=ProjectiveSpace(ZZ,2)
sage: Q=P([4,1,30])
sage: Q.global_height()
3.40119738166216
sage: R.<x>=PolynomialRing(QQ)
sage: k.<w>=NumberField(x^2+5)
sage: A=ProjectiveSpace(k,2,'z')
sage: A([3,5*w+1,1]).global_height(prec=100)
2.4181409534757389986565376694
green_function(G, v, **kwds)

Evaluates the local Green’s function with respect to the morphism G at the place v for self 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 The Arithmetic of Dynamics Systems, Joseph H. Silverman, Springer, GTM 241, 2007.

INPUT:

  • G - a projective morphism whose local Green’s function we are computing
  • v - non-negative integer. a place, use v=0 for the archimedean place

kwds:

  • N - positive integer. number of terms of the series to use, default: 10
  • prec - positive integer, float point or p-adic precision, default: 100
  • error_bound - a positive real number

OUTPUT:

  • a real number

EXAMPLES:

sage: P.<x,y>=ProjectiveSpace(QQ,1)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,x*y]);
sage: Q=P(5,1)
sage: f.green_function(Q,0,N=30)
1.6460930159932946233759277576
sage: P.<x,y>=ProjectiveSpace(QQ,1)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,x*y]);
sage: Q=P(5,1)
sage: Q.green_function(f,0,N=200,prec=200)
1.6460930160038721802875250367738355497198064992657997569827
sage: K.<w> = QuadraticField(3)
sage: P.<x,y> = ProjectiveSpace(K,1)
sage: H = Hom(P,P)
sage: f = H([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: print f.green_function(P([2,1]), K.ideal(7), N=7)
0.48647753726382832627633818586
sage: print f.green_function(P([w,1]), K.ideal(17), error_bound=0.001)
-0.70761163353747779889947530309

Todo

Implement general p-adic extensions so that the flip trick can be used for number fields.

local_height(v, prec=None)

Returns the maximum of the local height of the coordinates of self.

INPUT:

  • v – a prime or prime ideal of the base ring
  • prec – desired floating point precision (default: default RealField precision).

OUTPUT:

  • a real number

EXAMPLES:

sage: P.<x,y,z>=ProjectiveSpace(QQ,2)
sage: Q=P.point([4,4,1/150],False)
sage: Q.local_height(5)
3.21887582486820
sage: P.<x,y,z>=ProjectiveSpace(QQ,2)
sage: Q=P([4,1,30])
sage: Q.local_height(2)
0.693147180559945
local_height_arch(i, prec=None)

Returns the maximum of the local heights at the i-th infinite place of self.

INPUT:

  • i – an integer
  • prec – desired floating point precision (default: default RealField precision).

OUTPUT:

  • a real number

EXAMPLES:

sage: P.<x,y,z>=ProjectiveSpace(QQ,2)
sage: Q = P.point([4,4,1/150], False)
sage: Q.local_height_arch(0)
1.38629436111989
sage: P.<x,y,z>=ProjectiveSpace(QuadraticField(5, 'w'),2)
sage: Q = P.point([4,1,30], False)
sage: Q.local_height_arch(1)
3.401197381662155375413236691607
multiplier(f, n, check=True)

Returns the multiplier of the projective point self of period \(n\) by the function \(f\). \(f\) must be an endomorphism of projective space

INPUT:

  • f - a endomorphism of self.codomain()
  • n - a positive integer, the period of self
  • check – check if P is periodic of period n, Default:True

OUTPUT:

  • a square matrix of size self.codomain().dimension_relative() in the base_ring of self

EXAMPLES:

sage: P.<x,y,z,w>=ProjectiveSpace(QQ,3)
sage: H=Hom(P,P)
sage: f=H([x^2,y^2,4*w^2,4*z^2]);
sage: Q=P.point([4,4,1,1],False);
sage: Q.multiplier(f,1)
[ 2  0 -8]
[ 0  2 -8]
[ 0  0 -2]
normalize_coordinates()

Removes the gcd from the coordinates of self (including \(-1\)).

Warning

The gcd will depend on the base ring.

OUTPUT: None.

EXAMPLES:

sage: P = ProjectiveSpace(ZZ,2,'x')
sage: p = P([-5,-15,-20])
sage: p.normalize_coordinates(); p
(1 : 3 : 4)
sage: P = ProjectiveSpace(Zp(7),2,'x')
sage: p = P([-5,-15,-2])
sage: p.normalize_coordinates(); p
(5 + O(7^20) : 1 + 2*7 + O(7^20) : 2 + O(7^20))
sage: R.<t> = PolynomialRing(QQ)
sage: P = ProjectiveSpace(R,2,'x')
sage: p = P([3/5*t^3,6*t, t])
sage: p.normalize_coordinates(); p
(3/5*t^2 : 6 : 1)
sage: P.<x,y> = ProjectiveSpace(Zmod(20),1)
sage: Q = P(3,6)
sage: Q.normalize_coordinates()
sage: Q
(1 : 2)

Since the base ring is a polynomial ring over a field, only the gcd \(c\) is removed.

sage: R.<c> = PolynomialRing(QQ)
sage: P = ProjectiveSpace(R,1)
sage: Q = P(2*c,4*c)
sage: Q.normalize_coordinates();Q
(2 : 4)

A polynomial ring over a ring gives the more intuitive result.

sage: R.<c> = PolynomialRing(ZZ)
sage: P = ProjectiveSpace(R,1)
sage: Q = P(2*c,4*c)
sage: Q.normalize_coordinates();Q
(1 : 2)
sage: R.<t> = PolynomialRing(QQ,1)
sage: S = R.quotient_ring(R.ideal(t^3))
sage: P.<x,y> = ProjectiveSpace(S,1)
sage: Q = P(t,t^2)
sage: Q.normalize_coordinates()
sage: Q
(1 : tbar)
nth_iterate(f, n, normalize=False)

For a map self and a point \(P\) in self.domain() this function returns the nth iterate of \(P\) by self. If normalize==True, then the coordinates are automatically normalized.

INPUT:

  • f – a SchmemMorphism_polynomial with self in f.domain()
  • n – a positive integer.
  • normalize – Boolean (optional Default: False)

OUTPUT:

  • A point in self.codomain()

EXAMPLES:

sage: P.<x,y>=ProjectiveSpace(ZZ,1)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,2*y^2])
sage: P(1,1).nth_iterate(f,4)
(32768 : 32768)
sage: P.<x,y>=ProjectiveSpace(ZZ,1)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,2*y^2])
sage: P(1,1).nth_iterate(f,4,1)
(1 : 1)
sage: R.<t>=PolynomialRing(QQ)
sage: P.<x,y,z>=ProjectiveSpace(R,2)
sage: H=Hom(P,P)
sage: f=H([x^2+t*y^2,(2-t)*y^2,z^2])
sage: P(2+t,7,t).nth_iterate(f,2)
(t^4 + 2507*t^3 - 6787*t^2 + 10028*t + 16 : -2401*t^3 + 14406*t^2 -
28812*t + 19208 : t^4)
sage: P.<x,y,z>=ProjectiveSpace(ZZ,2)
sage: X=P.subscheme(x^2-y^2)
sage: H=Hom(X,X)
sage: f=H([x^2,y^2,z^2])
sage: X(2,2,3).nth_iterate(f,3)
(256 : 256 : 6561)

Todo

Is there a more efficient way to do this?

orbit(f, N, **kwds)

Returns the orbit of \(P\) by self. If \(n\) is an integer it returns \([P,self(P),\ldots,self^n(P)]\). If \(n\) is a list or tuple \(n=[m,k]\) it returns \([self^m(P),\ldots,self^k(P)\)]. Automatically normalize the points if normalize=True. Perform the checks on point initialization if check=True

INPUT:

  • f – a SchemeMorphism_polynomial with self in f.domain()
  • N – a non-negative integer or list or tuple of two non-negative integers

kwds:

  • check – boolean (optional - default: True)
  • normalize – boolean (optional - default: False)

OUTPUT:

  • a list of points in self.codomain()

EXAMPLES:

sage: P.<x,y,z>=ProjectiveSpace(ZZ,2)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,y^2-z^2,2*z^2])
sage: P(1,2,1).orbit(f,3)
[(1 : 2 : 1), (5 : 3 : 2), (34 : 5 : 8), (1181 : -39 : 128)]
sage: P.<x,y,z>=ProjectiveSpace(ZZ,2)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,y^2-z^2,2*z^2])
sage: P(1,2,1).orbit(f,[2,4])
[(34 : 5 : 8), (1181 : -39 : 128), (1396282 : -14863 : 32768)]
sage: P.<x,y,z>=ProjectiveSpace(ZZ,2)
sage: X=P.subscheme(x^2-y^2)
sage: H=Hom(X,X)
sage: f=H([x^2,y^2,x*z])
sage: X(2,2,3).orbit(f,3,normalize=True)
[(2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3), (2 : 2 : 3)]
sage: P.<x,y>=ProjectiveSpace(QQ,1)
sage: H=Hom(P,P)
sage: f=H([x^2+y^2,y^2])
sage: P.point([1,2],False).orbit(f,4,check=False)
[(1 : 2), (5 : 4), (41 : 16), (1937 : 256), (3817505 : 65536)]
scale_by(t)

Scale the coordinates of the point self by \(t\). A TypeError occurs if the point is not in the base_ring of the codomain after scaling.

INPUT:

  • t – a ring element

OUTPUT: None.

EXAMPLES:

sage: R.<t> = PolynomialRing(QQ)
sage: P = ProjectiveSpace(R, 2, 'x')
sage: p = P([3/5*t^3, 6*t, t])
sage: p.scale_by(1/t); p
(3/5*t^2 : 6 : 1)
sage: R.<t> = PolynomialRing(QQ)
sage: S = R.quo(R.ideal(t^3))
sage: P.<x,y,z> = ProjectiveSpace(S, 2)
sage: Q = P(t,1,1)
sage: Q.scale_by(t);Q
(tbar^2 : tbar : tbar)
sage: P.<x,y,z> = ProjectiveSpace(ZZ,2)
sage: Q = P(2,2,2)
sage: Q.scale_by(1/2);Q
(1 : 1 : 1)

Previous topic

Projective \(n\) space over a ring

Next topic

Morphisms on projective varieties

This Page