### Navigation

- index
- modules |
- next |
- previous |
- Schemes »

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

  `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([1,3,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)

  `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 canonical height of `self` with respect to `F`. Must be over \(\ZZ\) or \(\QQ\). Specify either the number of terms of the series to evaluate or, in dimension 1, the error bound required.

    ALGORITHM:

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

    INPUT:

    - `P` - a projective point

    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.4989058602918874235863427216e-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. Must be over \(\ZZ\) or \(\QQ\).

    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

    Todo

    p-adic heights

  `green_function`(G, v, **kwds)

    Evaluates the local Green’s function at the place `v` for `self` with `N` terms of the series or, in dimension 1, to within the specified error bound. Defaults to `N=10` if no kwds provided

    Use `v=0` for the archimedean place. Must be over \(\ZZ\) or \(\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` - an endomorphism of self.codomain()
    - `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
    - `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

    Todo

    error bounds for dimension > 1

  `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(4,8)
        sage: Q.normalize_coordinates()
        sage: 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 : t)

    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)

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

### Navigation

- index
- modules |
- next |
- previous |
- Schemes »