# Projective $$n$$ space over a ring¶

EXAMPLES:

We construct projective space over various rings of various dimensions.

The simplest projective space:

sage: ProjectiveSpace(0)
Projective Space of dimension 0 over Integer Ring


A slightly bigger projective space over $$\QQ$$:

sage: X = ProjectiveSpace(1000, QQ); X
Projective Space of dimension 1000 over Rational Field
sage: X.dimension()
1000


We can use “over” notation to create projective spaces over various base rings.

sage: X = ProjectiveSpace(5)/QQ; X
Projective Space of dimension 5 over Rational Field
sage: X/CC
Projective Space of dimension 5 over Complex Field with 53 bits of precision


The third argument specifies the printing names of the generators of the homogenous coordinate ring. Using the method $$.objgens()$$ you can obtain both the space and the generators as ready to use variables.

sage: P2, vars = ProjectiveSpace(10, QQ, 't').objgens()
sage: vars
(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)


You can alternatively use the special syntax with < and >.

sage: P2.<x,y,z> = ProjectiveSpace(2, QQ)
sage: P2
Projective Space of dimension 2 over Rational Field
sage: P2.coordinate_ring()
Multivariate Polynomial Ring in x, y, z over Rational Field


The first of the three lines above is just equivalent to the two lines:

sage: P2 = ProjectiveSpace(2, QQ, 'xyz')
sage: x,y,z = P2.gens()


For example, we use $$x,y,z$$ to define the intersection of two lines.

sage: V = P2.subscheme([x+y+z, x+y-z]); V
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x + y + z,
x + y - z
sage: V.dimension()
0


AUTHORS:

• Ben Hutz: (June 2012): support for rings
• Ben Hutz (9/2014): added support for Cartesian products
• Rebecca Lauren Miller (March 2016) : added point_transformation_matrix
sage.schemes.projective.projective_space.ProjectiveSpace(n, R=None, names='x')

Return projective space of dimension n over the ring R.

EXAMPLES: The dimension and ring can be given in either order.

sage: ProjectiveSpace(3, QQ)
Projective Space of dimension 3 over Rational Field
sage: ProjectiveSpace(5, QQ)
Projective Space of dimension 5 over Rational Field
sage: P = ProjectiveSpace(2, QQ, names='XYZ'); P
Projective Space of dimension 2 over Rational Field
sage: P.coordinate_ring()
Multivariate Polynomial Ring in X, Y, Z over Rational Field


The divide operator does base extension.

sage: ProjectiveSpace(5)/GF(17)
Projective Space of dimension 5 over Finite Field of size 17


The default base ring is $$\ZZ$$.

sage: ProjectiveSpace(5)
Projective Space of dimension 5 over Integer Ring


There is also an projective space associated each polynomial ring.

sage: R = GF(7)['x,y,z']
sage: P = ProjectiveSpace(R); P
Projective Space of dimension 2 over Finite Field of size 7
sage: P.coordinate_ring()
Multivariate Polynomial Ring in x, y, z over Finite Field of size 7
sage: P.coordinate_ring() is R
True

sage: ProjectiveSpace(3, Zp(5), 'y')
Projective Space of dimension 3 over 5-adic Ring with capped relative precision 20

sage: ProjectiveSpace(2,QQ,'x,y,z')
Projective Space of dimension 2 over Rational Field

sage: PS.<x,y>=ProjectiveSpace(1,CC)
sage: PS
Projective Space of dimension 1 over Complex Field with 53 bits of precision

sage: R.<x,y,z> = QQ[]
sage: ProjectiveSpace(R).variable_names()
('x', 'y', 'z')


Projective spaces are not cached, i.e., there can be several with the same base ring and dimension (to facilitate gluing constructions).

sage: R.<x> = QQ[]
sage: ProjectiveSpace(R)
Projective Space of dimension 0 over Rational Field

class sage.schemes.projective.projective_space.ProjectiveSpace_field(n, R=Integer Ring, names=None)
curve(F)

Return a curve defined by F in this projective space.

INPUT:

• F – a polynomial, or a list or tuple of polynomials in the coordinate ring of this projective space.

EXAMPLES:

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: P.curve([y^2 - x*z])
Projective Plane Curve over Rational Field defined by y^2 - x*z

point_transformation_matrix(points_source, points_target)

Returns a unique element of PGL that transforms one set of points to another.

Given a projective space of degree n and a set of n+2 source points and a set of n+2 target points in the same projective space, such that no n+1 points of each set are linearly dependent finds the unique element of PGL that translates the source points to the target points.

Warning :: will not work over precision fields

INPUT:

• points_source - points in source projective space.
• points_target - points in target projective space.

OUTPUT: Transformation matrix - element of PGL.

EXAMPLES:

sage: P1.<a,b,c>=ProjectiveSpace(QQ, 2)
sage: points_source=[P1([1,4,1]),P1([1,2,2]),P1([3,5,1]),P1([1,-1,1])]
sage: points_target=[P1([5,-2,7]),P1([3,-2,3]),P1([6,-5,9]), P1([3,6,7])]
sage: m = P1.point_transformation_matrix(points_source, points_target); m
[ -13/59 -128/59  -25/59]
[538/177    8/59  26/177]
[ -45/59 -196/59       1]
sage: [P1(list(m*vector(list(points_source[i])))) == points_target[i] for i in range(4)]
[True, True, True, True]

sage: P.<a,b> = ProjectiveSpace(GF(13),1)
sage: points_source = [P([-6,7]), P([1,4]), P([3,2])]
sage: points_target = [P([-1,2]), P([0,2]), P([-1,6])]
sage: P.point_transformation_matrix(points_source, points_target)
[10  4]
[10  1]

sage: P.<a,b> = ProjectiveSpace(QQ,1)
sage: points_source = [P([-6,-4]), P([1,4]), P([3,2])]
sage: points_target = [P([-1,2]), P([0,2]), P([-7,-3])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: source points not independent

sage: P.<a,b> = ProjectiveSpace(QQ,1)
sage: points_source = [P([-6,-1]), P([1,4]), P([3,2])]
sage: points_target = [P([-1,2]), P([0,2]), P([-2,4])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: target points not independent

sage: P.<a,b,c>=ProjectiveSpace(QQ, 2)
sage: points_source=[P([1,4,1]),P([2,-7,9]),P([3,5,1])]
sage: points_target=[P([5,-2,7]),P([3,-2,3]),P([6,-5,9]),P([6,-1,1])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: incorrect number of points in source, need 4 points

sage: P.<a,b,c>=ProjectiveSpace(QQ, 2)
sage: points_source=[P([1,4,1]),P([2,-7,9]),P([3,5,1]),P([1,-1,1])]
sage: points_target=[P([5,-2,7]),P([3,-2,3]),P([6,-5,9]),P([6,-1,1]),P([7,8,-9])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: incorrect number of points in target, need 4 points

sage: P.<a,b,c>=ProjectiveSpace(QQ, 2)
sage: P1.<x,y,z>=ProjectiveSpace(QQ, 2)
sage: points_source=[P([1,4,1]),P([2,-7,9]),P([3,5,1]),P1([1,-1,1])]
sage: points_target=[P([5,-2,7]),P([3,-2,3]),P([6,-5,9]),P([6,-1,1])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: source points not in self

sage: P.<a,b,c>=ProjectiveSpace(QQ, 2)
sage: P1.<x,y,z>=ProjectiveSpace(QQ, 2)
sage: points_source=[P([1,4,1]),P([2,-7,9]),P([3,5,1]),P([1,-1,1])]
sage: points_target=[P([5,-2,7]),P([3,-2,3]),P([6,-5,9]),P1([6,-1,1])]
sage: P.point_transformation_matrix(points_source, points_target)
Traceback (most recent call last):
...
ValueError: target points not in self

points_of_bounded_height(**kwds)

Returns an iterator of the points in self of absolute height of at most the given bound.

Bound check is strict for the rational field. Requires self to be projective space over a number field. Uses the Doyle-Krumm algorithm 4 (algorithm 5 for imaginary quadratic) for computing algebraic numbers up to a given height [Doyle-Krumm].

The algorithm requires floating point arithmetic, so the user is allowed to specify the precision for such calculations. Additionally, due to floating point issues, points slightly larger than the bound may be returned. This can be controlled by lowering the tolerance.

INPUT:

kwds:

• bound - a real number
• tolerance - a rational number in (0,1] used in doyle-krumm algorithm-4
• precision - the precision to use for computing the elements of bounded height of number fields.

OUTPUT:

• an iterator of points in this space

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: sorted(list(P.points_of_bounded_height(bound=5)))
[(0 : 1), (1 : -5), (1 : -4), (1 : -3), (1 : -2), (1 : -1), (1 : 0),
(1 : 1), (1 : 2), (1 : 3), (1 : 4), (1 : 5), (2 : -5), (2 : -3),
(2 : -1), (2 : 1), (2 : 3), (2 : 5), (3 : -5), (3 : -4), (3 : -2),
(3 : -1), (3 : 1), (3 : 2), (3 : 4), (3 : 5), (4 : -5), (4 : -3),
(4 : -1), (4 : 1), (4 : 3), (4 : 5), (5 : -4), (5 : -3), (5 : -2),
(5 : -1), (5 : 1), (5 : 2), (5 : 3), (5 : 4)]

sage: u = QQ['u'].0
sage: P.<x,y,z> = ProjectiveSpace(NumberField(u^2 - 2, 'v'), 2)
sage: len(list(P.points_of_bounded_height(bound=1.5, tolerance=0.1)))
57

subscheme_from_Chow_form(Ch, dim)

Returns the subscheme defined by the Chow equations associated to the Chow form Ch.

These equations define the subscheme set-theoretically, but only for smooth subschemes and hypersurfaces do they define the subscheme as a scheme.

ALGORITHM:

The Chow form is a polynomial in the Plucker coordinates. The Plucker coordinates are the bracket polynomials. We first re-write the Chow form in terms of the dual Plucker coordinates. Then we expand $$Ch(span(p,L)$$ for a generic point $$p$$ and a generic linear subspace $$L$$. The coefficients as polynomials in the coordinates of $$p$$ are the equations defining the subscheme. [DalbecSturmfels].

INPUT:

• Ch - a homogeneous polynomial.
• dim - the dimension of the associated scheme.

OUTPUT: a projective subscheme.

EXAMPLES:

sage: P = ProjectiveSpace(QQ, 4, 'z')
sage: R.<x0,x1,x2,x3,x4> = PolynomialRing(QQ)
sage: H = x1^2 + x2^2 + 5*x3*x4
sage: P.subscheme_from_Chow_form(H,3)
Closed subscheme of Projective Space of dimension 4 over Rational Field defined by:
-5*z0*z1 + z2^2 + z3^2

sage: P = ProjectiveSpace(QQ, 3, 'z')
sage: R.<x0,x1,x2,x3,x4,x5> = PolynomialRing(QQ)
sage: H = x1-x2-x3+x5+2*x0
sage: P.subscheme_from_Chow_form(H, 1)
Closed subscheme of Projective Space of dimension 3 over Rational Field
defined by:
-z1 + z3,
z0 + z2 + z3,
-z1 - 2*z3,
-z0 - z1 + 2*z2

sage: P.<x0,x1,x2,x3> = ProjectiveSpace(GF(7), 3)
sage: X = P.subscheme([x3^2+x1*x2,x2-x0])
sage: Ch = X.Chow_form();Ch
t0^2 - 2*t0*t3 + t3^2 - t2*t4 - t4*t5
sage: Y = P.subscheme_from_Chow_form(Ch, 1); Y
Closed subscheme of Projective Space of dimension 3 over Finite Field of
size 7 defined by:
x1*x2 + x3^2,
-x0*x2 + x2^2,
-x0*x1 - x1*x2 - 2*x3^2,
x0^2 - x0*x2,
x0*x1 + x3^2,
-2*x0*x3 + 2*x2*x3,
2*x0*x3 - 2*x2*x3,
x0^2 - 2*x0*x2 + x2^2
sage: I = Y.defining_ideal()
sage: I.saturation(I.ring().ideal(list(I.ring().gens())))[0]
Ideal (x0 - x2, x1*x2 + x3^2) of Multivariate Polynomial Ring in x0, x1,
x2, x3 over Finite Field of size 7

class sage.schemes.projective.projective_space.ProjectiveSpace_finite_field(n, R=Integer Ring, names=None)
rational_points(F=None)

Return the list of F-rational points on this projective space, where F is a given finite field, or the base ring of this space.

EXAMPLES:

sage: P = ProjectiveSpace(1, GF(3))
sage: P.rational_points()
[(0 : 1), (1 : 1), (2 : 1), (1 : 0)]
sage: P.rational_points(GF(3^2, 'b'))
[(0 : 1), (b : 1), (b + 1 : 1), (2*b + 1 : 1), (2 : 1), (2*b : 1), (2*b + 2 : 1), (b + 2 : 1), (1 : 1), (1 : 0)]

rational_points_dictionary()

Return dictionary of points.

OUTPUT:

• dictionary

EXAMPLES:

sage: P1 = ProjectiveSpace(GF(7),1,'x')
sage: P1.rational_points_dictionary()
{(0 : 1): 0,
(1 : 0): 7,
(1 : 1): 1,
(2 : 1): 2,
(3 : 1): 3,
(4 : 1): 4,
(5 : 1): 5,
(6 : 1): 6}

class sage.schemes.projective.projective_space.ProjectiveSpace_rational_field(n, R=Integer Ring, names=None)
rational_points(bound=0)
Returns the projective points $$(x_0:\cdots:x_n)$$ over $$\QQ$$ with $$|x_i| \leq$$ bound.

ALGORITHM:

The very simple algorithm works as follows: every point $$(x_0:\cdots:x_n)$$ in projective space has a unique largest index $$i$$ for which $$x_i$$ is not zero. The algorithm then iterates downward on this index. We normalize by choosing $$x_i$$ positive. Then, the points $$x_0,\ldots,x_{i-1}$$ are the points of affine $$i$$-space that are relatively prime to $$x_i$$. We access these by using the Tuples method.

INPUT:

• bound - integer.

EXAMPLES:

sage: PP = ProjectiveSpace(0, QQ)
sage: PP.rational_points(1)
[(1)]
sage: PP = ProjectiveSpace(1, QQ)
sage: PP.rational_points(2)
[(-2 : 1), (-1 : 1), (0 : 1), (1 : 1), (2 : 1), (-1/2 : 1), (1/2 : 1), (1 : 0)]
sage: PP = ProjectiveSpace(2, QQ)
sage: PP.rational_points(2)
[(-2 : -2 : 1), (-1 : -2 : 1), (0 : -2 : 1), (1 : -2 : 1), (2 : -2 : 1),
(-2 : -1 : 1), (-1 : -1 : 1), (0 : -1 : 1), (1 : -1 : 1), (2 : -1 : 1),
(-2 : 0 : 1), (-1 : 0 : 1), (0 : 0 : 1), (1 : 0 : 1), (2 : 0 : 1), (-2 :
1 : 1), (-1 : 1 : 1), (0 : 1 : 1), (1 : 1 : 1), (2 : 1 : 1), (-2 : 2 :
1), (-1 : 2 : 1), (0 : 2 : 1), (1 : 2 : 1), (2 : 2 : 1), (-1/2 : -1 :
1), (1/2 : -1 : 1), (-1 : -1/2 : 1), (-1/2 : -1/2 : 1), (0 : -1/2 : 1),
(1/2 : -1/2 : 1), (1 : -1/2 : 1), (-1/2 : 0 : 1), (1/2 : 0 : 1), (-1 :
1/2 : 1), (-1/2 : 1/2 : 1), (0 : 1/2 : 1), (1/2 : 1/2 : 1), (1 : 1/2 :
1), (-1/2 : 1 : 1), (1/2 : 1 : 1), (-2 : 1 : 0), (-1 : 1 : 0), (0 : 1 :
0), (1 : 1 : 0), (2 : 1 : 0), (-1/2 : 1 : 0), (1/2 : 1 : 0), (1 : 0 :
0)]


AUTHORS:

• Benjamin Antieau (2008-01-12)
class sage.schemes.projective.projective_space.ProjectiveSpace_ring(n, R=Integer Ring, names=None)

Projective space of dimension $$n$$ over the ring $$R$$.

EXAMPLES:

sage: X.<x,y,z,w> = ProjectiveSpace(3, QQ)
sage: X.base_scheme()
Spectrum of Rational Field
sage: X.base_ring()
Rational Field
sage: X.structure_morphism()
Scheme morphism:
From: Projective Space of dimension 3 over Rational Field
To:   Spectrum of Rational Field
Defn: Structure map
sage: X.coordinate_ring()
Multivariate Polynomial Ring in x, y, z, w over Rational Field


sage: loads(X.dumps()) == X
True
sage: P = ProjectiveSpace(ZZ, 1, 'x')
True


Equality and hashing:

sage: ProjectiveSpace(QQ, 3, 'a') == ProjectiveSpace(ZZ, 3, 'a')
False
sage: ProjectiveSpace(ZZ, 1, 'a') == ProjectiveSpace(ZZ, 0, 'a')
False
sage: ProjectiveSpace(ZZ, 2, 'a') == AffineSpace(ZZ, 2, 'a')
False

sage: ProjectiveSpace(QQ, 3, 'a') != ProjectiveSpace(ZZ, 3, 'a')
True
sage: ProjectiveSpace(ZZ, 1, 'a') != ProjectiveSpace(ZZ, 0, 'a')
True
sage: ProjectiveSpace(ZZ, 2, 'a') != AffineSpace(ZZ, 2, 'a')
True

sage: hash(ProjectiveSpace(QQ, 3, 'a')) == hash(ProjectiveSpace(ZZ, 3, 'a'))
False
sage: hash(ProjectiveSpace(ZZ, 1, 'a')) == hash(ProjectiveSpace(ZZ, 0, 'a'))
False
sage: hash(ProjectiveSpace(ZZ, 2, 'a')) == hash(AffineSpace(ZZ, 2, 'a'))
False

Lattes_map(E, m)

Given an elliptic curve E and an integer m return the Lattes map associated to multiplication by $$m$$.

In other words, the rational map on the quotient $$E/\{\pm 1\} \cong \mathbb{P}^1$$ associated to $$[m]:E \to E$$.

INPUT:

• E – an elliptic curve.
• m – an integer.

OUTPUT: a dynamical system on this projective space.

Examples:

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: E = EllipticCurve(QQ,[-1, 0])
sage: P.Lattes_map(E, 2)
Dynamical System of Projective Space of dimension 1 over Rational Field
Defn: Defined on coordinates by sending (x : y) to
(1/4*x^4 + 1/2*x^2*y^2 + 1/4*y^4 : x^3*y - x*y^3)

affine_patch(i, AA=None)

Return the $$i^{th}$$ affine patch of this projective space.

This is an ambient affine space $$\mathbb{A}^n_R,$$ where $$R$$ is the base ring of self, whose “projective embedding” map is $$1$$ in the $$i^{th}$$ factor.

INPUT:

• i – integer between 0 and dimension of self, inclusive.
• AA – (default: None) ambient affine space, this is constructed
if it is not given.

OUTPUT:

• An ambient affine space with fixed projective_embedding map.

EXAMPLES:

sage: PP = ProjectiveSpace(5) / QQ
sage: AA = PP.affine_patch(2)
sage: AA
Affine Space of dimension 5 over Rational Field
sage: AA.projective_embedding()
Scheme morphism:
From: Affine Space of dimension 5 over Rational Field
To:   Projective Space of dimension 5 over Rational Field
Defn: Defined on coordinates by sending (x0, x1, x3, x4, x5) to
(x0 : x1 : 1 : x3 : x4 : x5)
sage: AA.projective_embedding(0)
Scheme morphism:
From: Affine Space of dimension 5 over Rational Field
To:   Projective Space of dimension 5 over Rational Field
Defn: Defined on coordinates by sending (x0, x1, x3, x4, x5) to
(1 : x0 : x1 : x3 : x4 : x5)

sage: P.<x,y> = ProjectiveSpace(QQ,1)
sage: P.affine_patch(0).projective_embedding(0).codomain() == P
True

cartesian_product(other)

Return the Cartesian product of this projective space and other.

INPUT:

• other - A projective space with the same base ring as this space.

OUTPUT:

• A Cartesian product of projective spaces.

EXAMPLES:

sage: P1 = ProjectiveSpace(QQ, 1, 'x')
sage: P2 = ProjectiveSpace(QQ, 2, 'y')
sage: PP = P1.cartesian_product(P2); PP
Product of projective spaces P^1 x P^2 over Rational Field
sage: PP.gens()
(x0, x1, y0, y1, y2)

change_ring(R)

Return a projective space over ring R.

INPUT:

• R – commutative ring or morphism.

OUTPUT:

• projective space over R.

Note

There is no need to have any relation between R and the base ring of this space, if you want to have such a relation, use self.base_extend(R) instead.

EXAMPLES:

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)
sage: PQ = P.change_ring(QQ); PQ
Projective Space of dimension 2 over Rational Field
sage: PQ.change_ring(GF(5))
Projective Space of dimension 2 over Finite Field of size 5

sage: K.<w> = QuadraticField(2)
sage: P = ProjectiveSpace(K,2,'t')
sage: P.change_ring(K.embeddings(QQbar)[0])
Projective Space of dimension 2 over Algebraic Field

chebyshev_polynomial(n, kind='first')

Generates an endomorphism of this projective line by a Chebyshev polynomial.

Chebyshev polynomials are a sequence of recursively defined orthogonal polynomials. Chebyshev of the first kind are defined as $$T_0(x) = 1$$, $$T_1(x) = x$$, and $$T_{n+1}(x) = 2xT_n(x) - T_{n-1}(x)$$. Chebyshev of the second kind are defined as $$U_0(x) = 1$$, $$U_1(x) = 2x$$, and $$U_{n+1}(x) = 2xU_n(x) - U_{n-1}(x)$$.

INPUT:

• n – a non-negative integer.
• kindfirst or second specifying which kind of chebyshev the user would like to generate. Defaults to first.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: P.chebyshev_polynomial(5, 'first')
Dynamical System of Projective Space of dimension 1 over Rational Field
Defn: Defined on coordinates by sending (x : y) to
(16*x^5 - 20*x^3*y^2 + 5*x*y^4 : y^5)

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: P.chebyshev_polynomial(3, 'second')
Dynamical System of Projective Space of dimension 1 over Rational Field
Defn: Defined on coordinates by sending (x : y) to
(8*x^3 - 4*x*y^2 : y^3)

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: P.chebyshev_polynomial(3, 2)
Traceback (most recent call last):
...
ValueError: keyword 'kind' must have a value of either 'first' or 'second'

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: P.chebyshev_polynomial(-4, 'second')
Traceback (most recent call last):
...
ValueError: first parameter 'n' must be a non-negative integer

sage: P = ProjectiveSpace(QQ, 2, 'x')
sage: P.chebyshev_polynomial(2)
Traceback (most recent call last):
...
TypeError: projective space must be of dimension 1

coordinate_ring()

Return the coordinate ring of this scheme.

EXAMPLES:

sage: ProjectiveSpace(3, GF(19^2,'alpha'), 'abcd').coordinate_ring()
Multivariate Polynomial Ring in a, b, c, d over Finite Field in alpha of size 19^2

sage: ProjectiveSpace(3).coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2, x3 over Integer Ring

sage: ProjectiveSpace(2, QQ, ['alpha', 'beta', 'gamma']).coordinate_ring()
Multivariate Polynomial Ring in alpha, beta, gamma over Rational Field

is_projective()

Return that this ambient space is projective $$n$$-space.

EXAMPLES:

sage: ProjectiveSpace(3,QQ).is_projective()
True

ngens()

Return the number of generators of this projective space.

This is the number of variables in the coordinate ring of self.

EXAMPLES:

sage: ProjectiveSpace(3, QQ).ngens()
4
sage: ProjectiveSpace(7, ZZ).ngens()
8

point(v, check=True)

Create a point on this projective space.

INPUT:

• v – anything that defines a point
• check – boolean (optional, default: True); whether to check the defining data for consistency

OUTPUT: A point of this projective space.

EXAMPLES:

sage: P2 = ProjectiveSpace(QQ, 2)
sage: P2.point([4,5])
(4 : 5 : 1)

sage: P = ProjectiveSpace(QQ, 1)
sage: P.point(infinity)
(1 : 0)

sage: P = ProjectiveSpace(QQ, 2)
sage: P.point(infinity)
Traceback (most recent call last):
...
ValueError: +Infinity not well defined in dimension > 1

sage: P = ProjectiveSpace(ZZ, 2)
sage: P.point([infinity])
Traceback (most recent call last):
...
ValueError: [+Infinity] not well defined in dimension > 1

subscheme(X)

Return the closed subscheme defined by X.

INPUT:

• X - a list or tuple of equations.

EXAMPLES:

sage: A.<x,y,z> = ProjectiveSpace(2, QQ)
sage: X = A.subscheme([x*z^2, y^2*z, x*y^2]); X
Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x*z^2,
y^2*z,
x*y^2
sage: X.defining_polynomials ()
(x*z^2, y^2*z, x*y^2)
sage: I = X.defining_ideal(); I
Ideal (x*z^2, y^2*z, x*y^2) of Multivariate Polynomial Ring in x, y, z over Rational Field
sage: I.groebner_basis()
[x*y^2, y^2*z,  x*z^2]
sage: X.dimension()
0
sage: X.base_ring()
Rational Field
sage: X.base_scheme()
Spectrum of Rational Field
sage: X.structure_morphism()
Scheme morphism:
From: Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:
x*z^2,
y^2*z,
x*y^2
To:   Spectrum of Rational Field
Defn: Structure map

sage: TestSuite(X).run(skip=["_test_an_element", "_test_elements",            "_test_elements_eq", "_test_some_elements", "_test_elements_eq_reflexive",            "_test_elements_eq_symmetric", "_test_elements_eq_transitive",            "_test_elements_neq"])

veronese_embedding(d, CS=None, order='lex')

Return the degree d Veronese embedding from this projective space.

INPUT:

• d – a positive integer.
• CS – a projective ambient space to embed into. If this projective space has dimension $$N$$, the dimension of CS must be $$\binom{N + d}{d} - 1$$. This is constructed if not specified. Default: None.
• order – a monomial order to use to arrange the monomials defining the embedding. The monomials will be arranged from greatest to least with respect to this order. Default: 'lex'.

OUTPUT:

• a scheme morphism from this projective space to CS.

EXAMPLES:

sage: P.<x,y> = ProjectiveSpace(QQ, 1)
sage: vd = P.veronese_embedding(4, order='invlex')
sage: vd
Scheme morphism:
From: Projective Space of dimension 1 over Rational Field
To:   Projective Space of dimension 4 over Rational Field
Defn: Defined on coordinates by sending (x : y) to
(y^4 : x*y^3 : x^2*y^2 : x^3*y : x^4)


Veronese surface:

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)
sage: Q.<q,r,s,t,u,v> = ProjectiveSpace(QQ, 5)
sage: vd = P.veronese_embedding(2, Q)
sage: vd
Scheme morphism:
From: Projective Space of dimension 2 over Rational Field
To:   Projective Space of dimension 5 over Rational Field
Defn: Defined on coordinates by sending (x : y : z) to
(x^2 : x*y : x*z : y^2 : y*z : z^2)
sage: vd(P.subscheme([]))
Closed subscheme of Projective Space of dimension 5 over Rational Field
defined by:
-u^2 + t*v,
-s*u + r*v,
-s*t + r*u,
-s^2 + q*v,
-r*s + q*u,
-r^2 + q*t

sage.schemes.projective.projective_space.is_ProjectiveSpace(x)

Return True if x is a projective space.

In other words, if x is an ambient space $$\mathbb{P}^n_R$$, where $$R$$ is a ring and $$n\geq 0$$ is an integer.

EXAMPLES:

sage: from sage.schemes.projective.projective_space import is_ProjectiveSpace
sage: is_ProjectiveSpace(ProjectiveSpace(5, names='x'))
True
sage: is_ProjectiveSpace(ProjectiveSpace(5, GF(9,'alpha'), names='x'))
True
sage: is_ProjectiveSpace(Spec(ZZ))
False