Points for products of projective spaces

This class builds on the projective space class and its point and morphism classes.

EXAMPLES:

We construct products projective spaces of various dimensions over the same ring.:

sage: P1xP1.<x,y, u,v> = ProductProjectiveSpaces(QQ, [1, 1])
sage: P1xP1([2, 1, 3, 1])
(2 : 1 , 3 : 1)
class sage.schemes.product_projective.point.ProductProjectiveSpaces_point_field(parent, polys, check=True)

Bases: sage.schemes.product_projective.point.ProductProjectiveSpaces_point_ring

The Python constructor.

INPUT:

  • parent – Hom-set.
  • polys – anything that defines a point in the class.
  • check – Boolean. Whether or not to perform input checks. (Default: True)

EXAMPLES:

sage: P1.<x0,x1,x2> = ProjectiveSpace(QQ, 2)
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: T = ProductProjectiveSpaces([P1, P2])
sage: Q1 = P1(1, 1, 1)
sage: Q2 = P2(1, 2, 3, 4)
sage: T([Q1, Q2])
(1 : 1 : 1 , 1/4 : 1/2 : 3/4 : 1)

sage: T = ProductProjectiveSpaces([2, 2, 2], GF(5), 'x')
sage: T.point([1, 2, 3, 4, 5, 6, 7, 8, 9])
(2 : 4 : 1 , 4 : 0 : 1 , 3 : 2 : 1)

sage: T.<x,y,z,w> = ProductProjectiveSpaces([1, 1], GF(5))
sage: X = T.subscheme([x-y, z-2*w])
sage: X([1, 1, 2, 1])
(1 : 1 , 2 : 1)
intersection_multiplicity(X)

Return the intersection multiplicity of the codomain of this point and subscheme X at this point.

This uses the subscheme implementation of intersection_multiplicity. This point must be a point on a subscheme of a product of projective spaces.

INPUT:

  • X – a subscheme in the same ambient space as the codomain of this point.

OUTPUT: An integer.

EXAMPLES:

sage: PP.<x,y,z,u,v> = ProductProjectiveSpaces(QQ, [2,1])
sage: X = PP.subscheme([y^2*z^3*u - x^5*v])
sage: Y = PP.subscheme([u^3 - v^3, x - y])
sage: Q = X([0,0,1,1,1])
sage: Q.intersection_multiplicity(Y)
2
multiplicity()

Return the multiplicity of this point on its codomain.

This uses the subscheme implementation of multiplicity. This point must be a point on a subscheme of a product of projective spaces.

OUTPUT: an integer.

EXAMPLES:

sage: PP.<x,y,z,w,u,v,t> = ProductProjectiveSpaces(QQ, [3,2])
sage: X = PP.subscheme([x^8*t - y^8*t + z^5*w^3*v])
sage: Q1 = X([1,1,0,0,-1,-1,1])
sage: Q1.multiplicity()
1
sage: Q2 = X([0,0,0,1,0,1,1])
sage: Q2.multiplicity()
5
sage: Q3 = X([0,0,0,1,1,0,0])
sage: Q3.multiplicity()
6
class sage.schemes.product_projective.point.ProductProjectiveSpaces_point_finite_field(parent, polys, check=True)

Bases: sage.schemes.product_projective.point.ProductProjectiveSpaces_point_field

The Python constructor.

INPUT:

  • parent – Hom-set.
  • polys – anything that defines a point in the class.
  • check – Boolean. Whether or not to perform input checks. (Default: True)

EXAMPLES:

sage: P1.<x0,x1,x2> = ProjectiveSpace(QQ, 2)
sage: P2 = ProjectiveSpace(QQ, 3, 'y')
sage: T = ProductProjectiveSpaces([P1, P2])
sage: Q1 = P1(1, 1, 1)
sage: Q2 = P2(1, 2, 3, 4)
sage: T([Q1, Q2])
(1 : 1 : 1 , 1/4 : 1/2 : 3/4 : 1)

sage: T = ProductProjectiveSpaces([2, 2, 2], GF(5), 'x')
sage: T.point([1, 2, 3, 4, 5, 6, 7, 8, 9])
(2 : 4 : 1 , 4 : 0 : 1 , 3 : 2 : 1)

sage: T.<x,y,z,w> = ProductProjectiveSpaces([1, 1], GF(5))
sage: X = T.subscheme([x-y, z-2*w])
sage: X([1, 1, 2, 1])
(1 : 1 , 2 : 1)
class sage.schemes.product_projective.point.ProductProjectiveSpaces_point_ring(parent, polys, check=True)

Bases: sage.schemes.generic.morphism.SchemeMorphism_point

The class of points on products of projective spaces.

The components are projective space points.

EXAMPLES:

sage: T.<x,y,z,w,u> = ProductProjectiveSpaces([2, 1], QQ)
sage: T.point([1, 2, 3, 4, 5]);
(1/3 : 2/3 : 1 , 4/5 : 1)
change_ring(R, **kwds)

Returns a new ProductProjectiveSpaces_point which is this point coerced to R.

If the keyword check is True, then the initialization checks are performed. The user may specify the embedding into R with a keyword.

INPUT:

  • R – ring.

kwds:

  • check – Boolean.
  • embedding – field embedding from the base ring of this point to R.

OUTPUT:

ProductProjectiveSpaces_point.

EXAMPLES:

sage: T.<x,y,z,u,v,w> = ProductProjectiveSpaces([1, 1, 1], ZZ)
sage: P = T.point([5, 3, 15, 4, 2, 6]);
sage: P.change_ring(GF(3))
(1 : 0 , 0 : 1 , 1 : 0)
normalize_coordinates()

Removes common factors (componentwise) from the coordinates of this point (including \(-1\)).

OUTPUT: None.

EXAMPLES:

sage: T.<x,y,z,u,v,w> = ProductProjectiveSpaces([2, 2], ZZ)
sage: P = T.point([5, 10, 15, 4, 2, 6]);
sage: P.normalize_coordinates()
sage: P
(1 : 2 : 3 , 2 : 1 : 3)
nth_iterate(f, n, normalize=False)

For a map of this point and a point \(P\) in self.domain() this function returns the nth iterate of \(P\) by this point.

If normalize == True, then the coordinates are automatically normalized.

INPUT:

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

OUTPUT:

  • A point in self.codomain()

EXAMPLES:

sage: Z.<a,b,x,y> = ProductProjectiveSpaces([1, 1], ZZ)
sage: f = DynamicalSystem_projective([a*b, b^2, x^3 - y^3, y^2*x], domain=Z)
sage: P = Z([2, 6, 2, 4])
sage: P.nth_iterate(f, 2, normalize = True)
doctest:warning
...
(1 : 3 , 407 : 112)

Todo

Is there a more efficient way to do this?

orbit(f, N, **kwds)

Returns the orbit this point by f.

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 ProductProjectiveSpaces_morphism_ring with the orbit of \(P\) 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: Z.<a,b,x,y> = ProductProjectiveSpaces([1, 1], ZZ)
sage: f = DynamicalSystem_projective([a*b, b^2, x^3 - y^3, y^2*x], domain=Z)
sage: P = Z([2, 6, 2, 4])
sage: P.orbit(f, 3, normalize = True)
doctest:warning
...
[(1 : 3 , 1 : 2), (1 : 3 , -7 : 4), (1 : 3 , 407 : 112), (1 : 3 , 66014215 : 5105408)]
scale_by(t)

Scale the coordinates of the point by t, done componentwise.

A TypeError occurs if the point is not in the base ring of the codomain after scaling.

INPUT:

  • t – a ring element

EXAMPLES:

sage: T.<x, y, z, u, v, w> = ProductProjectiveSpaces([1, 1, 1], ZZ)
sage: P = T.point([5, 10, 15, 4, 2, 6]);
sage: P.scale_by([2, 1, 1])
sage: P
(10 : 20 , 15 : 4 , 2 : 6)