Coverage for local/lib/python2.7/site-packages/sage/schemes/generic/algebraic

'Quasi-projective subscheme X - Y of Projective Space of dimension 2 over Integer Ring, where X is defined by:\n (no polynomials)\nand Y is defined by:\n x - y'

"""

if sage.schemes.affine.affine_space.is_AffineSpace(self.ambient_space()):

t = "affine"

else:

t = "projective"

return ("Quasi-%s subscheme X - Y of %s, where X is defined by:\n%s\n"

"and Y is defined by:\n%s"

% (t, self.ambient_space(), str(self.__X).split("\n", 1)[1],

str(self.__Y).split("\n", 1)[1]))

def X(self):

"""

Return the scheme `X` such that self is represented as `X - Y`.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)

sage: S = P.subscheme([])

sage: T = P.subscheme([x-y])

sage: U = T.complement(S)

sage: U.X() is S

True

"""

return self.__X

def Y(self):

"""

Return the scheme `Y` such that self is represented as `X - Y`.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)

sage: S = P.subscheme([])

sage: T = P.subscheme([x-y])

sage: U = T.complement(S)

sage: U.Y() is T

True

"""

return self.__Y

def _check_satisfies_equations(self, v):

"""

Verify that the coordinates of v define a point on this scheme, or

raise a TypeError.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)

sage: S = P.subscheme([])

sage: T = P.subscheme([x-y])

sage: U = T.complement(S)

sage: U._check_satisfies_equations([1, 2, 0])

True

sage: U._check_satisfies_equations([1, 1, 0])

Traceback (most recent call last):

...

TypeError: Coordinates [1, 1, 0] do not define a point on

Quasi-projective subscheme X - Y of Projective Space of dimension 2

over Integer Ring, where X is defined by:

(no polynomials)

and Y is defined by:

x - y

sage: U._check_satisfies_equations([1, 4])

Traceback (most recent call last):

...

TypeError: number of arguments does not match number of variables in parent

sage: A.<x, y> = AffineSpace(2, GF(7))

sage: S = A.subscheme([x^2-y])

sage: T = A.subscheme([x-y])

sage: U = T.complement(S)

sage: U._check_satisfies_equations([2, 4])

True

sage: U.point([2,4])

(2, 4)

sage: U._check_satisfies_equations(_)

True

sage: U._check_satisfies_equations([1, 1])

Traceback (most recent call last):

...

TypeError: Coordinates [1, 1] do not define a point on Quasi-affine

subscheme X - Y of Affine Space of dimension 2 over Finite

Field of size 7, where X is defined by:

x^2 - y

and Y is defined by:

x - y

sage: U._check_satisfies_equations([1, 0])

Traceback (most recent call last):

...

TypeError: Coordinates [1, 0] do not define a point on Quasi-affine

subscheme X - Y of Affine Space of dimension 2 over Finite

Field of size 7, where X is defined by:

x^2 - y

and Y is defined by:

x - y

TESTS:

The bug reported at :trac:`12211` has been fixed::

sage: P.<x, y, z, w> = ProjectiveSpace(3, QQ)

sage: S = P.subscheme([x])

sage: T = P.subscheme([y, z])

sage: U = T.complement(S)

sage: U._check_satisfies_equations([0, 0, 1, 1])

True

"""

coords = list(v)

for f in self.__X.defining_polynomials():

if f(coords) != 0:

raise TypeError("Coordinates %s do not define a point on %s"%(v,self))

for f in self.__Y.defining_polynomials():

if f(coords) != 0:

return True

raise TypeError("Coordinates %s do not define a point on %s"%(v,self))

def rational_points(self, F=None, bound=0):

"""

Return the set of rational points on this algebraic scheme

over the field `F`.

EXAMPLES::

sage: A.<x, y> = AffineSpace(2, GF(7))

sage: S = A.subscheme([x^2-y])

sage: T = A.subscheme([x-y])

sage: U = T.complement(S)

sage: U.rational_points()

[(2, 4), (3, 2), (4, 2), (5, 4), (6, 1)]

sage: U.rational_points(GF(7^2, 'b'))

[(2, 4), (3, 2), (4, 2), (5, 4), (6, 1), (b, b + 4), (b + 1, 3*b + 5), (b + 2, 5*b + 1),

(b + 3, 6), (b + 4, 2*b + 6), (b + 5, 4*b + 1), (b + 6, 6*b + 5), (2*b, 4*b + 2),

(2*b + 1, b + 3), (2*b + 2, 5*b + 6), (2*b + 3, 2*b + 4), (2*b + 4, 6*b + 4),

(2*b + 5, 3*b + 6), (2*b + 6, 3), (3*b, 2*b + 1), (3*b + 1, b + 2), (3*b + 2, 5),

(3*b + 3, 6*b + 3), (3*b + 4, 5*b + 3), (3*b + 5, 4*b + 5), (3*b + 6, 3*b + 2),

(4*b, 2*b + 1), (4*b + 1, 3*b + 2), (4*b + 2, 4*b + 5), (4*b + 3, 5*b + 3),

(4*b + 4, 6*b + 3), (4*b + 5, 5), (4*b + 6, b + 2), (5*b, 4*b + 2), (5*b + 1, 3),

(5*b + 2, 3*b + 6), (5*b + 3, 6*b + 4), (5*b + 4, 2*b + 4), (5*b + 5, 5*b + 6),

(5*b + 6, b + 3), (6*b, b + 4), (6*b + 1, 6*b + 5), (6*b + 2, 4*b + 1), (6*b + 3, 2*b + 6),

(6*b + 4, 6), (6*b + 5, 5*b + 1), (6*b + 6, 3*b + 5)]

"""

if F is None:

F = self.base_ring()

if bound == 0:

if is_RationalField(F):

raise TypeError("A positive bound (= %s) must be specified."%bound)

if not is_FiniteField(F):

raise TypeError("Argument F (= %s) must be a finite field."%F)

pts = []

for P in self.ambient_space().rational_points(F):

try:

if self._check_satisfies_equations(list(P)):

pts.append(P)

except TypeError:

pass

pts.sort()

return pts

#*******************************************************************

@richcmp_method

class AlgebraicScheme_subscheme(AlgebraicScheme):

"""

An algebraic scheme presented as a closed subscheme is defined by

explicit polynomial equations. This is as opposed to a general

scheme, which could, e.g., be the Neron model of some object, and

for which we do not want to give explicit equations.

INPUT:

- ``A`` - ambient space (e.g. affine or projective `n`-space)

- ``polynomials`` - single polynomial, ideal or iterable of defining

polynomials; in any case polynomials must belong to the coordinate

ring of the ambient space and define valid polynomial functions (e.g.

they should be homogeneous in the case of a projective space)

OUTPUT:

- algebraic scheme

EXAMPLES::

sage: from sage.schemes.generic.algebraic_scheme import AlgebraicScheme_subscheme

sage: P.<x, y, z> = ProjectiveSpace(2, QQ)

sage: P.subscheme([x^2-y*z])

Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

sage: AlgebraicScheme_subscheme(P, [x^2-y*z])

Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

"""

def __init__(self, A, polynomials):

"""

See ``AlgebraicScheme_subscheme`` for documentation.

TESTS::

sage: from sage.schemes.generic.algebraic_scheme import AlgebraicScheme_subscheme

sage: P.<x, y, z> = ProjectiveSpace(2, QQ)

sage: P.subscheme([x^2-y*z])

Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

sage: AlgebraicScheme_subscheme(P, [x^2-y*z])

Closed subscheme of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

"""

from sage.rings.polynomial.multi_polynomial_sequence import is_PolynomialSequence

AlgebraicScheme.__init__(self, A)

self._base_ring = A.base_ring()

R = A.coordinate_ring()

if is_Ideal(polynomials):

I = polynomials

polynomials = I.gens()

if I.ring() is R: # Otherwise we will recompute I later after

self.__I = I # converting generators to the correct ring

if isinstance(polynomials, tuple) or is_PolynomialSequence(polynomials) or is_iterator(polynomials):

polynomials = list(polynomials)

elif not isinstance(polynomials, list):

# Looks like we got a single polynomial

polynomials = [polynomials]

for n, f in enumerate(polynomials):

try:

polynomials[n] = R(f)

except TypeError:

raise TypeError("%s cannot be converted to a polynomial in "

"the coordinate ring of this %s!" % (f, A))

polynomials = tuple(polynomials)

self.__polys = A._validate(polynomials)

def _check_satisfies_equations(self, v):

"""

Verify that the coordinates of v define a point on this scheme, or

raise a TypeError.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, QQ)

sage: S = P.subscheme([x^2-y*z])

sage: S._check_satisfies_equations([1, 1, 1])

True

sage: S._check_satisfies_equations([1, 0, 1])

Traceback (most recent call last):

...

TypeError: Coordinates [1, 0, 1] do not define a point on Closed subscheme

of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

sage: S._check_satisfies_equations([0, 0, 0])

Traceback (most recent call last):

...

TypeError: Coordinates [0, 0, 0] do not define a point on Closed subscheme

of Projective Space of dimension 2 over Rational Field defined by:

x^2 - y*z

"""

coords = list(v)

for f in self.defining_polynomials():

if f(coords) != 0: # it must be "!=0" instead of "if f(v)", e.g.,

# because of p-adic base rings.

raise TypeError("Coordinates %s do not define a point on %s"%(coords,self))

try:

return self.ambient_space()._check_satisfies_equations(coords)

except TypeError:

raise TypeError("Coordinates %s do not define a point on %s"%(coords,self))

def base_extend(self, R):

"""

Return the base change to the ring `R` of this scheme.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, GF(11))

sage: S = P.subscheme([x^2-y*z])

sage: S.base_extend(GF(11^2, 'b'))

Closed subscheme of Projective Space of dimension 2 over Finite Field in b of size 11^2 defined by:

x^2 - y*z

sage: S.base_extend(ZZ)

Traceback (most recent call last):

...

ValueError: no natural map from the base ring (=Finite Field of size 11) to R (=Integer Ring)!

"""

A = self.ambient_space().base_extend(R)

return A.subscheme(self.__polys)

def __richcmp__(self, other, op):

"""

EXAMPLES::

sage: A.<x, y, z> = AffineSpace(3, QQ)

sage: X = A.subscheme([x*y, z])

sage: X == A.subscheme([z, x*y])

True

sage: X == A.subscheme([x*y, z^2])

False

sage: B.<u, v, t> = AffineSpace(3, QQ)

sage: X == B.subscheme([u*v, t])

False

"""

if not isinstance(other, AlgebraicScheme_subscheme):

return NotImplemented

A = self.ambient_space()

if other.ambient_space() != A:

return NotImplemented

return richcmp(self.defining_ideal(), other.defining_ideal(), op)

def _latex_(self):

"""

Return a LaTeX representation of this scheme.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, GF(11))

sage: S = P.subscheme([x^2-y*z])

sage: S

Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:

x^2 - y*z

sage: S._latex_()

'\\text{Closed subscheme of } {\\mathbf P}_{\\Bold{F}_{11}}^2 \\text{ defined by } x^{2} - y z'

sage: S = P.subscheme([x^2-y*z, x^5])

sage: S

Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:

x^2 - y*z,

x^5

sage: S._latex_()

'\\text{Closed subscheme of } {\\mathbf P}_{\\Bold{F}_{11}}^2 \\text{ defined by } x^{2} - y z, x^{5}'

"""

polynomials = ', '.join(latex(f) for f in self.defining_polynomials())

if not polynomials:

polynomials = r"\text{no polynomials}"

return (r"\text{Closed subscheme of } %s \text{ defined by } %s"

% (latex(self.ambient_space()), polynomials))

def _repr_(self):

r"""

Return a string representation of this scheme.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, GF(11))

sage: S = P.subscheme([x^2-y*z])

sage: S

Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:

x^2 - y*z

sage: S._repr_()

'Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:\n x^2 - y*z'

sage: S = P.subscheme([x^2-y*z, x^5])

sage: S

Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:

x^2 - y*z,

x^5

sage: S._repr_()

'Closed subscheme of Projective Space of dimension 2 over Finite Field of size 11 defined by:\n x^2 - y*z,\n x^5'

"""

polynomials = ',\n '.join(str(f) for f in self.defining_polynomials())

if not polynomials:

polynomials = '(no polynomials)'

return ("Closed subscheme of %s defined by:\n %s"

% (self.ambient_space(), polynomials))

def defining_polynomials(self):

"""

Return the polynomials that define this scheme as a subscheme

of its ambient space.

OUTPUT:

A tuple of polynomials in the coordinate ring of the ambient

space.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)

sage: S = P.subscheme([x^2-y*z, x^3+z^3])

sage: S.defining_polynomials()

(x^2 - y*z, x^3 + z^3)

"""

return self.__polys

def defining_ideal(self):

"""

Return the ideal that defines this scheme as a subscheme

of its ambient space.

OUTPUT:

An ideal in the coordinate ring of the ambient space.

EXAMPLES::

sage: P.<x, y, z> = ProjectiveSpace(2, ZZ)

sage: S = P.subscheme([x^2-y*z, x^3+z^3])

sage: S.defining_ideal()

Ideal (x^2 - y*z, x^3 + z^3) of Multivariate Polynomial Ring in x, y, z over Integer Ring

"""

try:

return self.__I

except AttributeError:

R = self.ambient_space().coordinate_ring()

self.__I = R.ideal(self.defining_polynomials())

return self.__I

# Note: dimension must be implemented by the derived classes

def codimension(self):

r"""

Return the codimension of the algebraic subscheme.

OUTPUT:

Integer.

EXAMPLES::

sage: PP.<x,y,z,w,v> = ProjectiveSpace(4,QQ)

sage: V = PP.subscheme(x*y)

sage: V.codimension()

sage: V.dimension()

"""

return self.ambient_space().dimension() - self.dimension()

def irreducible_components(self):

r"""

Return the irreducible components of this algebraic scheme, as

subschemes of the same ambient space.

OUTPUT:

an immutable sequence of irreducible subschemes of the ambient

space of this scheme

The components are cached.

EXAMPLES:

We define what is clearly a union of four hypersurfaces in

`\P^4_{\QQ}` then find the irreducible components::

sage: PP.<x,y,z,w,v> = ProjectiveSpace(4,QQ)

sage: V = PP.subscheme( (x^2 - y^2 - z^2)*(w^5 - 2*v^2*z^3)* w * (v^3 - x^2*z) )

sage: V.irreducible_components()

[

Closed subscheme of Projective Space of dimension 4 over Rational Field defined by:

x^2 - y^2 - z^2,

Closed subscheme of Projective Space of dimension 4 over Rational Field defined by:

x^2*z - v^3,

Closed subscheme of Projective Space of dimension 4 over Rational Field defined by:

w^5 - 2*z^3*v^2

]

We verify that the irrelevant ideal isn't accidently returned

(see :trac:`6920`)::

sage: PP.<x,y,z,w> = ProjectiveSpace(3,QQ)

sage: f = x^3 + y^3 + z^3 + w^3

sage: R = f.parent()

sage: I = [f] + [f.derivative(zz) for zz in PP.gens()]

sage: V = PP.subscheme(I)

sage: V.irreducible_components()

[

]

The same polynomial as above defines a scheme with a

nontrivial irreducible component in affine space (instead of

the empty scheme as above)::

sage: AA.<x,y,z,w> = AffineSpace(4,QQ)

sage: V = AA.subscheme(I)

sage: V.irreducible_components()

[

Closed subscheme of Affine Space of dimension 4 over Rational Field defined by:

]

"""

try:

return self.__irreducible_components

except AttributeError:

pass

I = self.defining_ideal()

P = I.associated_primes()

if self.is_projective():

# In the projective case, we must exclude the prime ideals

# that contain the irrelevant ideal, which is the ideal

# generated by the variables, which are the gens of the

# base ring.

G = I.ring().gens()

# We make a list of ideals with the property that "any"

# of the elements of G are not in the ideal.

P = [J for J in P if any(g not in J for g in G)]

A = self.ambient_space()

C = Sequence([A.subscheme(X) for X in P], check=False, cr=True)

C.sort(key=lambda scheme: scheme.defining_ideal().gens())

C.set_immutable()

self.__irreducible_components = C

return C

def is_irreducible(self):

r"""

Return whether this subscheme is or is not irreducible.

OUTPUT: Boolean.

EXAMPLES::

sage: K = QuadraticField(-3)

sage: P.<x,y,z,w,t,u> = ProjectiveSpace(K, 5)

sage: X = P.subscheme([x*y - z^2 - K.0*t^2, t*w*x + y*z^2 - u^3])

sage: X.is_irreducible()

True

sage: P.<x,y,z> = ProjectiveSpace(QQ, 2)

sage: X = P.subscheme([(y + x - z)^2])

sage: X.is_irreducible()

False

sage: A.<x,y,z,w> = AffineSpace(GF(17), 4)

sage: X = A.subscheme([x*y*z^2 - x*y*z*w - z*w^2 + w^3, x^3*y*z*w - x*y^3*z - x^2*y*z*w \

- x^2*w^3 + y^2*w^2 + x*w^3])

sage: X.is_irreducible()

False

"""

return self.defining_ideal().is_prime()

def Jacobian_matrix(self):

r"""

Return the matrix `\frac{\partial f_i}{\partial x_j}` of

(formal) partial derivatives.

OUTPUT:

A matrix of polynomials.

EXAMPLES::

sage: P3.<w,x,y,z> = ProjectiveSpace(3, QQ)

sage: twisted_cubic = P3.subscheme(matrix([[w, x, y],[x, y, z]]).minors(2))

sage: twisted_cubic.Jacobian_matrix()

[ y -2*x w 0]

[ z -y -x w]

[ 0 z -2*y x]

This example addresses ticket :trac:`20512`::

sage: X = P3.subscheme([])

sage: X.Jacobian_matrix().base_ring() == P3.coordinate_ring()

True

"""

R = self.ambient_space().coordinate_ring()

l = self.defining_polynomials()

if len(l) == 0:

return sage.matrix.constructor.Matrix(R, 0)

return jacobian(l, R.gens())

def Jacobian(self):

r"""

Return the Jacobian ideal.

This is the ideal generated by

* the `d\times d` minors of the Jacobian matrix, where `d` is

the :meth:`codimension` of the algebraic scheme, and

* the defining polynomials of the algebraic scheme. Note that

some authors do not include these in the definition of the

Jacobian ideal. An example of a reference that does include

the defining equations is [LazarsfeldJacobian]_.

OUTPUT:

An ideal in the coordinate ring of the ambient space.

REFERENCES:

.. [LazarsfeldJacobian]

Robert Lazarsfeld:

Positivity in algebraic geometry II;

Positivity for Vector Bundles, and Multiplier Ideals,

page 181.

EXAMPLES::

sage: P3.<w,x,y,z> = ProjectiveSpace(3, QQ)

sage: twisted_cubic = P3.subscheme(matrix([[w, x, y],[x, y, z]]).minors(2))

sage: twisted_cubic.Jacobian()

Ideal (-x^2 + w*y, -x*y + w*z, -y^2 + x*z, x*z, -2*w*z, w*y, 3*w*y, -2*w*x,

w^2, y*z, -2*x*z, w*z, 3*w*z, -2*w*y, w*x, z^2, -2*y*z, x*z, 3*x*z, -2*w*z,

w*y) of Multivariate Polynomial Ring in w, x, y, z over Rational Field

sage: twisted_cubic.defining_ideal()

Ideal (-x^2 + w*y, -x*y + w*z, -y^2 + x*z) of Multivariate Polynomial Ring

in w, x, y, z over Rational Field

This example addresses ticket :trac:`20512`::

sage: X = P3.subscheme([])

sage: X.Jacobian() == P3.coordinate_ring().unit_ideal()

True

"""

d = self.codimension()

minors = self.Jacobian_matrix().minors(d)

I = self.defining_ideal()

minors = tuple([ I.reduce(m) for m in minors ])

return I.ring().ideal(I.gens() + minors)

def reduce(self):

r"""

Return the corresponding reduced algebraic space associated to this

scheme.

EXAMPLES: First we construct the union of a doubled and tripled

line in the affine plane over `\QQ` ::

sage: A.<x,y> = AffineSpace(2, QQ)

sage: X = A.subscheme([(x-1)^2*(x-y)^3]); X

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x^5 - 3*x^4*y + 3*x^3*y^2 - x^2*y^3 - 2*x^4 + 6*x^3*y

- 6*x^2*y^2 + 2*x*y^3 + x^3 - 3*x^2*y + 3*x*y^2 - y^3

sage: X.dimension()

Then we compute the corresponding reduced scheme::

sage: Y = X.reduce(); Y

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x^2 - x*y - x + y

Finally, we verify that the reduced scheme `Y` is the union

of those two lines::

sage: L1 = A.subscheme([x-1]); L1

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x - 1

sage: L2 = A.subscheme([x-y]); L2

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x - y

sage: W = L1.union(L2); W # taken in ambient space

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x^2 - x*y - x + y

sage: Y == W

True

"""

try:

return self._reduce

except AttributeError:

r = self.defining_ideal().radical()

A = self.ambient_space()

V = A.subscheme(r)

V._reduce = V # so knows it is already reduced!

self._reduce = V

return V

def union(self, other):

"""

Return the scheme-theoretic union of self and other in their common

ambient space.

EXAMPLES: We construct the union of a line and a tripled-point on

the line.

sage: A.<x,y> = AffineSpace(2, QQ)

sage: I = ideal([x,y])^3

sage: P = A.subscheme(I)

sage: L = A.subscheme([y-1])

sage: S = L.union(P); S

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

y^4 - y^3,

x*y^3 - x*y^2,

x^2*y^2 - x^2*y,

x^3*y - x^3

sage: S.dimension()

sage: S.reduce()

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

y^2 - y,

x*y - x

We can also use the notation "+" for the union::

sage: A.subscheme([x]) + A.subscheme([y^2 - (x^3+1)])

Closed subscheme of Affine Space of dimension 2 over Rational Field defined by:

x^4 - x*y^2 + x

Saving and loading::

sage: loads(S.dumps()) == S

True

"""

if not isinstance(other, AlgebraicScheme_subscheme):

raise TypeError("other (=%s) must be a closed algebraic subscheme of an ambient space"%other)

A = self.ambient_space()

if other.ambient_space() != A:

raise ValueError("other (=%s) must be in the same ambient space as self"%other)

return A.subscheme(self.defining_ideal().intersection(other.defining_ideal()))

def __pow__(self, m):

"""

Return the Cartesian power of this space.

INPUT: ``m`` -- integer.

OUTPUT: subscheme of product of ambient spaces.

EXAMPLES::

sage: P2.<y0,y1,y2> = ProjectiveSpace(ZZ, 2)

sage: Z = P2.subscheme([y0^2 - y1*y2, y2])

sage: Z**3

Closed subscheme of Product of projective spaces P^2 x P^2 x P^2 over

Integer Ring defined by:

x0^2 - x1*x2,

x2,

x3^2 - x4*x5,

x5,

x6^2 - x7*x8,

sage: A2.<x,y> = AffineSpace(QQ, 2)

sage: V = A2.subscheme([x^2-y, x-1])

sage: V**4

Closed subscheme of Affine Space of dimension 8 over Rational Field

defined by:

x0^2 - x1,

x0 - 1,

x2^2 - x3,

x2 - 1,

x4^2 - x5,

x4 - 1,

x6^2 - x7,

x6 - 1

sage: T.<x0,x1,x2,x3,x4,x5> = ProductProjectiveSpaces([2,2], ZZ)

sage: X = T.subscheme([x0*x4 - x1*x3])

sage: X^2

Closed subscheme of Product of projective spaces P^2 x P^2 x P^2 x P^2

over Integer Ring defined by:

-x1*x3 + x0*x4,

-x7*x9 + x6*x10

sage: E = EllipticCurve([0,0,0,0,1])

sage: E^2

Closed subscheme of Product of projective spaces P^2 x P^2 over Rational

Field defined by:

-x0^3 + x1^2*x2 - x2^3,

-x3^3 + x4^2*x5 - x5^3

"""

AS = self.ambient_space().__pow__(m)

CR = AS.coordinate_ring()

n = self.ambient_space().coordinate_ring().ngens()

polys = []

for i in range(m):

phi = self.ambient_space().coordinate_ring().hom(list(CR.gens()[n*i : n*(i+1)]), CR)

polys.extend([phi(t) for t in self.defining_polynomials()])

return AS.subscheme(polys)

def __mul__(self, right):

r"""

Create the product of subschemes.

INPUT: ``right`` - a subscheme of similar type.

OUTPUT: a subscheme of a the product of the ambient spaces.

EXAMPLES::

sage: S = ProductProjectiveSpaces([1,2,1], ZZ, 't')

sage: T = ProductProjectiveSpaces([2,2], ZZ, 'x')

sage: T.inject_variables()

Defining x0, x1, x2, x3, x4, x5

sage: X = T.subscheme([x0*x4 - x1*x3])

sage: X*S

Closed subscheme of Product of projective spaces P^2 x P^2 x P^1 x P^2 x

P^1 over Integer Ring defined by:

-x1*x3 + x0*x4

sage: S = ProjectiveSpace(ZZ, 2, 't')

sage: T.<x0,x1,x2,x3> = ProjectiveSpace(ZZ, 3)

sage: X = T.subscheme([x0*x2 - x1*x3])

sage: X*S

Closed subscheme of Product of projective spaces P^3 x P^2

over Integer Ring defined by:

x0*x2 - x1*x3

sage: A2 = AffineSpace(ZZ, 2, 't')

sage: A3.<x0,x1,x2> = AffineSpace(ZZ, 3)

sage: X = A3.subscheme([x0*x2 - x1])

sage: X*A2

Closed subscheme of Affine Space of dimension 5 over Integer Ring

defined by:

x0*x2 - x1

sage: T.<x0,x1,x2,x3,x4,x5> = ProductProjectiveSpaces([2,2], ZZ)

sage: X = T.subscheme([x0*x4 - x1*x3])

sage: X*X

Closed subscheme of Product of projective spaces P^2 x P^2 x P^2 x P^2

over Integer Ring defined by:

-x1*x3 + x0*x4,

-x7*x9 + x6*x10

sage: P1.<z0,z1> = ProjectiveSpace(ZZ, 1)

sage: Y = P1.subscheme([z0 - z1])

sage: T.<x0,x1,x2,x3,x4,x5> = ProductProjectiveSpaces([2,2], ZZ)

sage: X = T.subscheme([x0*x4 - x1*x3])

sage: X*Y

Closed subscheme of Product of projective spaces P^2 x P^2 x P^1 over

Integer Ring defined by:

-x1*x3 + x0*x4,

z0 - z1

sage: A3.<x0,x1,x2> = AffineSpace(ZZ, 3)

sage: X = A3.subscheme([x0*x2 - x1])

sage: P1.<u,v>=ProjectiveSpace(ZZ,1)

sage: Y = P1.subscheme([u-v])

sage: X*Y

Traceback (most recent call last):

...

TypeError: Projective Space of dimension 1 over Integer Ring must be an affine space or affine subscheme

sage: Y*X

Traceback (most recent call last):

...

TypeError: Affine Space of dimension 3 over Integer Ring must be a projective space, product of projective spaces, or subscheme

sage: PP.<a,b,c,d>=ProductProjectiveSpaces(ZZ, [1,1])

sage: Z = PP.subscheme([a*d-b*c])

sage: X*Z

Traceback (most recent call last):

...

TypeError: Product of projective spaces P^1 x P^1 over Integer Ring must be an affine space or affine subscheme

sage: Z*X

Traceback (most recent call last):

...

TypeError: Affine Space of dimension 3 over Integer Ring must be a projective space, product of projective spaces, or subscheme

"""

#This will catch any ambient space mistmatches

AS = self.ambient_space()*right.ambient_space()

CR = AS.coordinate_ring()

n = self.ambient_space().coordinate_ring().ngens()

phi = self.ambient_space().coordinate_ring().hom(list(CR.gens()[:n]), CR)

psi = right.ambient_space().coordinate_ring().hom(list(CR.gens()[n:]), CR)

return AS.subscheme([phi(t) for t in self.defining_polynomials()] + [psi(t) for t in right.defining_polynomials()])

__add__ = union

def intersection(self, other):

"""

Return the scheme-theoretic intersection of self and other in their

common ambient space.

EXAMPLES::

sage: A.<x, y> = AffineSpace(2, ZZ)

sage: X = A.subscheme([x^2-y])

sage: Y = A.subscheme([y])

sage: X.intersection(Y)

Closed subscheme of Affine Space of dimension 2 over Integer Ring defined by:

x^2 - y,

"""

if not isinstance(other, AlgebraicScheme_subscheme):

raise TypeError("other (=%s) must be a closed algebraic subscheme of an ambient space"%other)

A = self.ambient_space()

if other.ambient_space() != A:

raise ValueError("other (=%s) must be in the same ambient space as self"%other)

return A.subscheme(self.defining_ideal() + other.defining_ideal())

def complement(self, other=None):

"""

Return the scheme-theoretic complement other - self, where

self and other are both closed algebraic subschemes of the

same ambient space.

If other is unspecified, it is taken to be the ambient space

of self.

EXAMPLES::

sage: A.<x, y, z> = AffineSpace(3, ZZ)

sage: X = A.subscheme([x+y-z])

sage: Y = A.subscheme([x-y+z])

sage: Y.complement(X)

Quasi-affine subscheme X - Y of Affine Space of

dimension 3 over Integer Ring, where X is defined by:

x + y - z

and Y is defined by:

x - y + z

sage: Y.complement()

Quasi-affine subscheme X - Y of Affine Space of

dimension 3 over Integer Ring, where X is defined by:

(no polynomials)

and Y is defined by:

x - y + z

sage: P.<x, y, z> = ProjectiveSpace(2, QQ)

sage: X = P.subscheme([x^2+y^2+z^2])

sage: Y = P.subscheme([x*y+y*z+z*x])

sage: Y.complement(X)

Quasi-projective subscheme X - Y of Projective Space of

dimension 2 over Rational Field, where X is defined by:

x^2 + y^2 + z^2

and Y is defined by:

x*y + x*z + y*z

sage: Y.complement(P)

Quasi-projective subscheme X - Y of Projective Space of

dimension 2 over Rational Field, where X is defined by:

(no polynomials)

and Y is defined by:

x*y + x*z + y*z

"""

A = self.ambient_space()

if other is None:

other = A.subscheme([])

elif not isinstance(other, AlgebraicScheme_subscheme):

if other == A:

other = A.subscheme([])

else:

raise TypeError("Argument other (=%s) must be a closed algebraic subscheme of an ambient space"%other)

if other.ambient_space() != A:

raise ValueError("other (=%s) must be in the same ambient space as self"%other)

return AlgebraicScheme_quasi(other, self)

def rational_points(self, bound=0, F=None):

"""

Return the rational points on the algebraic subscheme.

EXAMPLES:

Enumerate over a projective scheme over a number field::

sage: u = QQ['u'].0

sage: K.<v> = NumberField(u^2 + 3)

sage: A.<x,y> = ProjectiveSpace(K,1)

sage: X=A.subscheme(x^2 - y^2)

sage: X.rational_points(3)

[(-1 : 1), (1 : 1)]

One can enumerate points up to a given bound on a projective scheme

over the rationals::

sage: E = EllipticCurve('37a')

sage: E.rational_points(bound=8)

[(-1 : -1 : 1), (-1 : 0 : 1), (0 : -1 : 1), (0 : 0 : 1), (0 : 1 : 0), (1/4 : -5/8 : 1),

(1/4 : -3/8 : 1), (1 : -1 : 1), (1 : 0 : 1), (2 : -3 : 1), (2 : 2 : 1)]

For a small finite field, the complete set of points can be

enumerated. ::

sage: Etilde = E.base_extend(GF(3))

sage: Etilde.rational_points()

[(0 : 0 : 1), (0 : 1 : 0), (0 : 2 : 1), (1 : 0 : 1),

(1 : 2 : 1), (2 : 0 : 1), (2 : 2 : 1)]

The class of hyperelliptic curves does not (yet) support

desingularization of the places at infinity into two points::

sage: FF = FiniteField(7)

sage: P.<x> = PolynomialRing(FiniteField(7))

sage: C = HyperellipticCurve(x^8+x+1)

sage: C.rational_points()

[(0 : 1 : 0), (0 : 1 : 1), (0 : 6 : 1), (2 : 0 : 1),

(4 : 0 : 1), (6 : 1 : 1), (6 : 6 : 1)]

.. TODO::

1. The above algorithms enumerate all projective points and

test whether they lie on the scheme; Implement a more naive

sieve at least for covers of the projective line.

2. Implement Stoll's model in weighted projective space to

resolve singularities and find two points (1 : 1 : 0) and

(-1 : 1 : 0) at infinity.

"""

if F is None:

F = self.base_ring()

X = self.base_extend(F)(F)

if F in NumberFields() or F == ZZ:

try:

return X.points(bound) # checks for proper bound done in points functions

except TypeError:

raise TypeError("Unable to enumerate points over %s."%F)

try:

return X.points()

except TypeError:

raise TypeError("Unable to enumerate points over %s."%F)

def change_ring(self, R):

r"""

Returns a new algebraic subscheme which is this subscheme coerced to ``R``.

INPUT:

- ``R`` -- ring or morphism.

OUTPUT:

- A new algebraic subscheme which is this subscheme coerced to ``R``.

EXAMPLES::

sage: P.<x,y> = ProjectiveSpace(QQ, 1)

sage: X = P.subscheme([3*x^2-y^2])

sage: H = Hom(X,X)

sage: X.change_ring(GF(3))

Closed subscheme of Projective Space of dimension 1 over Finite Field of size 3 defined by:

-y^2

sage: K.<w> = QuadraticField(2)

sage: R.<z> = K[]

sage: L.<v> = K.extension(z^3-5)

sage: P.<x,y> = ProjectiveSpace(K, 1)

sage: X = P.subscheme(x - w*y)

sage: X.change_ring(L)

Closed subscheme of Projective Space of dimension 1 over Number Field in v with

defining polynomial z^3 - 5 over its base field defined by:

x + (-w)*y

sage: K.<w> = QuadraticField(2)

sage: R.<z> = K[]

sage: L.<v> = K.extension(z^3-5)

sage: P.<x,y,z> = AffineSpace(L,3)

sage: X = P.subscheme([x-w*y, z^2-v*x])

sage: emb = L.embeddings(QQbar)

sage: X.change_ring(emb[0])

Closed subscheme of Affine Space of dimension 3 over Algebraic Field

defined by:

x + (-1.414213562373095? + 0.?e-16*I)*y,

z^2 + (0.8549879733383485? + 1.480882609682365?*I)*x

sage: K.<w> = QuadraticField(2)

sage: R.<z> = K[]

sage: L.<v> = K.extension(z^3-5)

sage: P.<x,y,z> = AffineSpace(L,3)

sage: X = P.subscheme([x-w*y, z^2-v*x])

sage: emb = L.embeddings(QQbar)

sage: X.change_ring(emb[1])

Closed subscheme of Affine Space of dimension 3 over Algebraic Field

defined by:

x + (-1.414213562373095? + 0.?e-16*I)*y,

z^2 + (0.8549879733383485? - 1.480882609682365?*I)*x

sage: K.<w> = QuadraticField(-3)

sage: P.<x,y> = ProjectiveSpace(K, 1)

sage: X = P.subscheme(x-w*y)

sage: X.change_ring(CC)

Closed subscheme of Projective Space of dimension 1 over Complex Field

with 53 bits of precision defined by:

x + (-1.73205080756888*I)*y

sage: K.<w> = QuadraticField(3)

sage: P.<x,y> = ProjectiveSpace(K,1)

sage: X = P.subscheme(x-w*y)

sage: X.change_ring(RR)

Closed subscheme of Projective Space of dimension 1 over Real Field

with 53 bits of precision defined by:

x - 1.73205080756888*y

sage: K.<v> = CyclotomicField(7)

sage: O = K.maximal_order()

sage: P.<x,y> = ProjectiveSpace(O, 1)

sage: X = P.subscheme([x^2+O(v)*y^2])

sage: X.change_ring(CC)

Closed subscheme of Projective Space of dimension 1 over Complex Field

with 53 bits of precision defined by:

x^2 + (0.623489801858734 + 0.781831482468030*I)*y^2

sage: X.change_ring(K).change_ring(K.embeddings(QQbar)[0])

Closed subscheme of Projective Space of dimension 1 over Algebraic Field defined by:

x^2 + (-0.9009688679024191? - 0.4338837391175581?*I)*y^2

sage: R.<x> = QQ[]

sage: f = x^6-2

sage: L.<b> = NumberField(f, embedding=f.roots(CC)[2][0])

sage: A.<x,y> = AffineSpace(L, 2)

sage: H = Hom(A,A)

sage: X = A.subscheme([b*x^2, y^2])

sage: X.change_ring(CC)

Closed subscheme of Affine Space of dimension 2 over Complex Field with

53 bits of precision defined by:

(-0.561231024154687 - 0.972080648619833*I)*x^2,

y^2

"""

K = self.base_ring()

AS = self.ambient_space()

new_AS = AS.change_ring(R)

I = [f.change_ring(R) for f in self.defining_polynomials()]

return(new_AS.subscheme(I))

def weil_restriction(self):

r"""

Compute the Weil restriction of this variety over some extension

field. If the field is a finite field, then this computes

the Weil restriction to the prime subfield.

A Weil restriction of scalars - denoted `Res_{L/k}` - is a

functor which, for any finite extension of fields `L/k` and

any algebraic variety `X` over `L`, produces another

corresponding variety `Res_{L/k}(X)`, defined over `k`. It is

useful for reducing questions about varieties over large

fields to questions about more complicated varieties over

smaller fields.

This function does not compute this Weil restriction directly

but computes on generating sets of polynomial ideals:

Let `d` be the degree of the field extension `L/k`, let `a` a

generator of `L/k` and `p` the minimal polynomial of

`L/k`. Denote this ideal by `I`.

Specifically, this function first maps each variable `x` to

its representation over `k`: `\sum_{i=0}^{d-1} a^i x_i`. Then

each generator of `I` is evaluated over these representations

and reduced modulo the minimal polynomial `p`. The result is

interpreted as a univariate polynomial in `a` and its

coefficients are the new generators of the returned ideal.

If the input and the output ideals are radical, this is

equivalent to the statement about algebraic varieties above.

OUTPUT: Affine subscheme - the Weil restriction of ``self``.

EXAMPLES::

sage: R.<x> = QQ[]

sage: K.<w> = NumberField(x^5-2)

sage: R.<x> = K[]

sage: L.<v> = K.extension(x^2+1)

sage: A.<x,y> = AffineSpace(L,2)

sage: X = A.subscheme([y^2-L(w)*x^3-v])

sage: X.weil_restriction()

Closed subscheme of Affine Space of dimension 4 over Number Field in w

with defining polynomial x^5 - 2 defined by:

(-w)*z0^3 + (3*w)*z0*z1^2 + z2^2 - z3^2,

(-3*w)*z0^2*z1 + (w)*z1^3 + 2*z2*z3 - 1

sage: X.weil_restriction().ambient_space() is A.weil_restriction()

True

sage: A.<x,y,z> = AffineSpace(GF(5^2,'t'),3)

sage: X = A.subscheme([y^2-x*z, z^2+2*y])

sage: X.weil_restriction()

Closed subscheme of Affine Space of dimension 6 over Finite Field of

size 5 defined by:

z2^2 - 2*z3^2 - z0*z4 + 2*z1*z5,

2*z2*z3 + z3^2 - z1*z4 - z0*z5 - z1*z5,

z4^2 - 2*z5^2 + 2*z2,

2*z4*z5 + z5^2 + 2*z3

"""

try:

X = self.__weil_restriction

except AttributeError:

L = self.base_ring()

if L.is_finite():

d = L.degree()

else:

d = L.relative_degree()

if d == 1:

X = self

else:

A = self.ambient_space().weil_restriction()

I = self.defining_ideal().weil_restriction()

X = A.subscheme(I)

self.__weil_restriction = X

return X

def specialization(self, D=None, phi=None):

r"""

Specialization of this subscheme.

Given a family of maps defined over a polynomial ring. A specialization

is a particular member of that family. The specialization can be specified either

by a dictionary or a :class:`SpecializationMorphism`.

INPUT:

- ``D`` -- dictionary (optional)

- ``phi`` -- SpecializationMorphism (optional)

OUTPUT: :class:`SchemeMorphism_polynomial`

EXAMPLES::

sage: R.<c> = PolynomialRing(QQ)

sage: P.<x,y> = ProjectiveSpace(R, 1)

sage: X = P.subscheme([x^2 + c*y^2])

sage: X.specialization(dict({c:2}))

Closed subscheme of Projective Space of dimension 1 over Rational Field defined by:

x^2 + 2*y^2

sage: R.<c> = PolynomialRing(QQ)

sage: S.<a,b> = R[]

sage: P.<x,y,z> = AffineSpace(S,3)

sage: X = P.subscheme([x^2+a*c*y^2 - b*z^2])

sage: from sage.rings.polynomial.flatten import SpecializationMorphism

sage: phi = SpecializationMorphism(P.coordinate_ring(),dict({c:2,a:1}))

sage: X.specialization(phi=phi)

Closed subscheme of Affine Space of dimension 3 over Univariate Polynomial Ring in b over Rational Field defined by:

x^2 + 2*y^2 + (-b)*z^2

"""

if D is None:

if phi is None:

raise ValueError("either the dictionary or the specialization must be provided")

else:

from sage.rings.polynomial.flatten import SpecializationMorphism

phi = SpecializationMorphism(self.ambient_space().coordinate_ring(),D)

amb = self.ambient_space().change_ring(phi.codomain().base_ring())

return amb.subscheme([phi(g) for g in self.defining_polynomials()])

Coverage for local/lib/python2.7/site-packages/sage/schemes/generic/algebraic_scheme.py : 72%

308 statements 222 run 86 missing 0 excluded