# 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)
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)
class sage.schemes.product_projective.point.ProductProjectiveSpaces_point_ring(parent, polys, check=True)

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)

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

dehomogenize(L)

Dehomogenize $$k^{th}$$ point at $$L[k]^{th}$$ coordinate.

This function computes the appropriate affine patch using L and then returns the dehomogenized point on of this affine space.

INPUT:

• L - a list of non-negative integers

OUTPUT:

• SchemeMorphism_point_affine.

EXAMPLES:

sage: PP = ProductProjectiveSpaces([2, 2, 2], QQ, 'x')
sage: A = PP([2, 4, 6, 23, 46, 23, 9, 3, 1])
sage: A.dehomogenize([0, 1, 2])
(2, 3, 1/2, 1/2, 9, 3)

sage: PP.<a,b,x,y,z> = ProductProjectiveSpaces([1, 2], CC)
sage: X = PP.subscheme([a^2 + b^2])
sage: P = X([2, 2*i, -3, 6*i, 3 - 6*i])
sage: P.dehomogenize([1,0])
(-1.00000000000000*I, -2.00000000000000*I, -1.00000000000000 + 2.00000000000000*I)

sage: PP = ProductProjectiveSpaces([1, 1], ZZ)
sage: A = PP([0,1,2,4])
sage: A.dehomogenize([0,0])
Traceback (most recent call last):
...
ValueError: can't dehomogenize at 0 coordinate

global_height(prec=None)

Return the absolute logarithmic height of the point.

This function computes the maximum of global height of each component point in the product. Global height of component point is computed using function for projective point.

INPUT:

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

OUTPUT:

• a real number.

EXAMPLES:

sage: PP = ProductProjectiveSpaces(QQ, [2,2], 'x')
sage: Q = PP([1, 7, 5, 18, 2, 3])
sage: Q.global_height()
1.94591014905531

sage: PP = ProductProjectiveSpaces(ZZ, [1,1], 'x')
sage: A = PP([-30, 2, 1, 6])
sage: A.global_height()
3.40119738166216

sage: R.<x> = PolynomialRing(QQ)
sage: k.<w> = NumberField(x^2 + 5)
sage: PP = ProductProjectiveSpaces(k, [1, 2], 'y')
sage: Q = PP([3, 5*w+1, 1, 7*w, 10])
sage: Q.global_height()
2.30258509299405

sage: PP = ProductProjectiveSpaces(QQbar, [1, 1], 'x')
sage: Q = PP([1, QQbar(sqrt(2)), QQbar(5^(1/3)), QQbar(3^(1/3))])
sage: Q.global_height()
0.536479304144700

local_height(v, prec=None)

Return the maximum of the local height of the coordinates of this point.

This function computes the maximum of local height of each component point in the product. Local height of component point is computed using function for projective point.

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: PP = ProductProjectiveSpaces(QQ, [1, 1], 'x')
sage: A = PP([11, 5, 10, 2])
sage: A.local_height(5)
1.60943791243410

sage: P = ProductProjectiveSpaces(QQ, [1,2], 'x')
sage: Q = P([1, 4, 1/2, 2, 32])
sage: Q.local_height(2)
4.15888308335967

normalize_coordinates()

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

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