Schemes¶

AUTHORS:

William Stein, David Kohel, Kiran Kedlaya (2008): added zeta_series
Volker Braun (2011-08-11): documenting, improving, refactoring.

class sage.schemes.generic.scheme.AffineScheme(R, S=None, category=None)[source]¶

Bases: UniqueRepresentation, Scheme

Class for general affine schemes.

See also

For affine spaces over a base ring and subschemes thereof, see sage.schemes.generic.algebraic_scheme.AffineSpace.

Element[source]¶: alias of SchemeTopologicalPoint_prime_ideal

base_extend(R)[source]¶

Extend the base ring/scheme.

INPUT:

R – an affine scheme or a commutative ring

EXAMPLES:

Sage

sage: Spec_ZZ = Spec(ZZ);  Spec_ZZ
Spectrum of Integer Ring
sage: Spec_ZZ.base_extend(QQ)
Spectrum of Rational Field

sage: Spec(ZZ['x']).base_extend(Spec(QQ))
Spectrum of Univariate Polynomial Ring in x over Rational Field

Python

>>> from sage.all import *
>>> Spec_ZZ = Spec(ZZ);  Spec_ZZ
Spectrum of Integer Ring
>>> Spec_ZZ.base_extend(QQ)
Spectrum of Rational Field

>>> Spec(ZZ['x']).base_extend(Spec(QQ))
Spectrum of Univariate Polynomial Ring in x over Rational Field

Sage Live

Spec_ZZ = Spec(ZZ);  Spec_ZZ
Spec_ZZ.base_extend(QQ)
Spec(ZZ['x']).base_extend(Spec(QQ))

coordinate_ring()[source]¶

Return the underlying ring of this scheme.

OUTPUT: a commutative ring

EXAMPLES:

Sage

sage: Spec(QQ).coordinate_ring()
Rational Field
sage: Spec(PolynomialRing(QQ, 3, 'x')).coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2 over Rational Field

Python

>>> from sage.all import *
>>> Spec(QQ).coordinate_ring()
Rational Field
>>> Spec(PolynomialRing(QQ, Integer(3), 'x')).coordinate_ring()
Multivariate Polynomial Ring in x0, x1, x2 over Rational Field

Sage Live

Spec(QQ).coordinate_ring()
Spec(PolynomialRing(QQ, 3, 'x')).coordinate_ring()

dimension()[source]¶

Return the absolute dimension of this scheme.

OUTPUT: integer

EXAMPLES:

Sage

sage: S = Spec(ZZ)
sage: S.dimension_absolute()
1
sage: S.dimension()
1

Python

>>> from sage.all import *
>>> S = Spec(ZZ)
>>> S.dimension_absolute()
1
>>> S.dimension()
1

Sage Live

S = Spec(ZZ)
S.dimension_absolute()
S.dimension()

dimension_absolute()[source]¶

Return the absolute dimension of this scheme.

OUTPUT: integer

EXAMPLES:

Sage

sage: S = Spec(ZZ)
sage: S.dimension_absolute()
1
sage: S.dimension()
1

Python

>>> from sage.all import *
>>> S = Spec(ZZ)
>>> S.dimension_absolute()
1
>>> S.dimension()
1

Sage Live

S = Spec(ZZ)
S.dimension_absolute()
S.dimension()

dimension_relative()[source]¶

Return the relative dimension of this scheme over its base.

OUTPUT: integer

EXAMPLES:

Sage

sage: S = Spec(ZZ)
sage: S.dimension_relative()
0

Python

>>> from sage.all import *
>>> S = Spec(ZZ)
>>> S.dimension_relative()
0

Sage Live

S = Spec(ZZ)
S.dimension_relative()

hom(x, Y=None)[source]¶

Return the scheme morphism from self to Y defined by x.

INPUT:

x – anything that determines a scheme morphism; if x is a scheme, try to determine a natural map to x
Y – the codomain scheme (optional); if Y is not given, try to determine Y from context
check – boolean (default: True); whether to check the defining data for consistency

OUTPUT: the scheme morphism from self to Y defined by x

EXAMPLES:

We construct the inclusion from \(\mathrm{Spec}(\QQ)\) into \(\mathrm{Spec}(\ZZ)\) induced by the inclusion from \(\ZZ\) into \(\QQ\):

Sage

sage: X = Spec(QQ)
sage: X.hom(ZZ.hom(QQ))
Affine Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Natural morphism:
          From: Integer Ring
          To:   Rational Field

Python

>>> from sage.all import *
>>> X = Spec(QQ)
>>> X.hom(ZZ.hom(QQ))
Affine Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Natural morphism:
          From: Integer Ring
          To:   Rational Field

Sage Live

X = Spec(QQ)
X.hom(ZZ.hom(QQ))

is_noetherian()[source]¶

Return True if self is Noetherian, False otherwise.

EXAMPLES:

Sage

sage: Spec(ZZ).is_noetherian()
True

Python

>>> from sage.all import *
>>> Spec(ZZ).is_noetherian()
True

Sage Live

Spec(ZZ).is_noetherian()

class sage.schemes.generic.scheme.Scheme(X=None, category=None)[source]¶

Bases: Parent

The base class for all schemes.

INPUT:

X – a scheme, scheme morphism, commutative ring, commutative ring morphism, or None (optional). Determines the base scheme. If a commutative ring is passed, the spectrum of the ring will be used as base.
category – the category (optional); will be automatically constructed by default

EXAMPLES:

Sage

sage: from sage.schemes.generic.scheme import Scheme
sage: Scheme(ZZ)
<sage.schemes.generic.scheme.Scheme_with_category object at ...>

Python

>>> from sage.all import *
>>> from sage.schemes.generic.scheme import Scheme
>>> Scheme(ZZ)
<sage.schemes.generic.scheme.Scheme_with_category object at ...>

Sage Live

from sage.schemes.generic.scheme import Scheme
Scheme(ZZ)

A scheme is in the category of all schemes over its base:

Sage

sage: ProjectiveSpace(4, QQ).category()
Category of schemes over Rational Field

Python

>>> from sage.all import *
>>> ProjectiveSpace(Integer(4), QQ).category()
Category of schemes over Rational Field

Sage Live

ProjectiveSpace(4, QQ).category()

There is a special and unique \(\mathrm{Spec}(\ZZ)\) that is the default base scheme:

Sage

sage: Spec(ZZ).base_scheme() is Spec(QQ).base_scheme()
True

Python

>>> from sage.all import *
>>> Spec(ZZ).base_scheme() is Spec(QQ).base_scheme()
True

Sage Live

Spec(ZZ).base_scheme() is Spec(QQ).base_scheme()

base_extend(Y)[source]¶

Extend the base of the scheme.

Derived classes must override this method.

EXAMPLES:

Sage

sage: from sage.schemes.generic.scheme import Scheme
sage: X = Scheme(ZZ)
sage: X.base_scheme()
Spectrum of Integer Ring
sage: X.base_extend(QQ)
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> from sage.schemes.generic.scheme import Scheme
>>> X = Scheme(ZZ)
>>> X.base_scheme()
Spectrum of Integer Ring
>>> X.base_extend(QQ)
Traceback (most recent call last):
...
NotImplementedError

Sage Live

from sage.schemes.generic.scheme import Scheme
X = Scheme(ZZ)
X.base_scheme()
X.base_extend(QQ)

base_morphism()[source]¶

Return the structure morphism from self to its base scheme.

OUTPUT: a scheme morphism

EXAMPLES:

Sage

sage: A = AffineSpace(4, QQ)
sage: A.base_morphism()
Scheme morphism:
  From: Affine Space of dimension 4 over Rational Field
  To:   Spectrum of Rational Field
  Defn: Structure map

sage: X = Spec(QQ)
sage: X.base_morphism()
Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Structure map

Python

>>> from sage.all import *
>>> A = AffineSpace(Integer(4), QQ)
>>> A.base_morphism()
Scheme morphism:
  From: Affine Space of dimension 4 over Rational Field
  To:   Spectrum of Rational Field
  Defn: Structure map

>>> X = Spec(QQ)
>>> X.base_morphism()
Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Structure map

Sage Live

A = AffineSpace(4, QQ)
A.base_morphism()
X = Spec(QQ)
X.base_morphism()

base_ring()[source]¶

Return the base ring of the scheme self.

OUTPUT: a commutative ring

EXAMPLES:

Sage

sage: A = AffineSpace(4, QQ)
sage: A.base_ring()
Rational Field

sage: X = Spec(QQ)
sage: X.base_ring()
Integer Ring

Python

>>> from sage.all import *
>>> A = AffineSpace(Integer(4), QQ)
>>> A.base_ring()
Rational Field

>>> X = Spec(QQ)
>>> X.base_ring()
Integer Ring

Sage Live

A = AffineSpace(4, QQ)
A.base_ring()
X = Spec(QQ)
X.base_ring()

base_scheme()[source]¶

Return the base scheme.

OUTPUT: a scheme

EXAMPLES:

Sage

sage: A = AffineSpace(4, QQ)
sage: A.base_scheme()
Spectrum of Rational Field

sage: X = Spec(QQ)
sage: X.base_scheme()
Spectrum of Integer Ring

Python

>>> from sage.all import *
>>> A = AffineSpace(Integer(4), QQ)
>>> A.base_scheme()
Spectrum of Rational Field

>>> X = Spec(QQ)
>>> X.base_scheme()
Spectrum of Integer Ring

Sage Live

A = AffineSpace(4, QQ)
A.base_scheme()
X = Spec(QQ)
X.base_scheme()

coordinate_ring()[source]¶

Return the coordinate ring.

OUTPUT:

The global coordinate ring of this scheme, if defined. Otherwise this raises a ValueError.

EXAMPLES:

Sage

sage: R.<x, y> = QQ[]
sage: I = (x^2 - y^2)*R
sage: X = Spec(R.quotient(I))
sage: X.coordinate_ring()
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x^2 - y^2)

Python

>>> from sage.all import *
>>> R = QQ['x, y']; (x, y,) = R._first_ngens(2)
>>> I = (x**Integer(2) - y**Integer(2))*R
>>> X = Spec(R.quotient(I))
>>> X.coordinate_ring()
Quotient of Multivariate Polynomial Ring in x, y over Rational Field
 by the ideal (x^2 - y^2)

Sage Live

R.<x, y> = QQ[]
I = (x^2 - y^2)*R
X = Spec(R.quotient(I))
X.coordinate_ring()

count_points(n)[source]¶

Count points over finite fields.

INPUT:

n – integer

OUTPUT:

An integer. The number of points over \(\GF{q}, \ldots, \GF{q^n}\) on a scheme over a finite field \(\GF{q}\).

EXAMPLES:

Sage

sage: # needs sage.schemes
sage: P.<x> = PolynomialRing(GF(3))
sage: C = HyperellipticCurve(x^3 + x^2 + 1)
sage: C.count_points(4)
[6, 12, 18, 96]
sage: C.base_extend(GF(9,'a')).count_points(2)                              # needs sage.rings.finite_rings
[12, 96]

Python

>>> from sage.all import *
>>> # needs sage.schemes
>>> P = PolynomialRing(GF(Integer(3)), names=('x',)); (x,) = P._first_ngens(1)
>>> C = HyperellipticCurve(x**Integer(3) + x**Integer(2) + Integer(1))
>>> C.count_points(Integer(4))
[6, 12, 18, 96]
>>> C.base_extend(GF(Integer(9),'a')).count_points(Integer(2))                              # needs sage.rings.finite_rings
[12, 96]

Sage Live

# needs sage.schemes
P.<x> = PolynomialRing(GF(3))
C = HyperellipticCurve(x^3 + x^2 + 1)
C.count_points(4)
C.base_extend(GF(9,'a')).count_points(2)                              # needs sage.rings.finite_rings

Sage

sage: P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
sage: X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
sage: X.count_points(2)                                                     # needs sage.libs.singular sage.rings.finite_rings
[5, 17]

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(4), 't'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)# needs sage.rings.finite_rings
>>> X = P.subscheme([y**Integer(2)*z - x**Integer(3) - z**Integer(3)])                                  # needs sage.rings.finite_rings
>>> X.count_points(Integer(2))                                                     # needs sage.libs.singular sage.rings.finite_rings
[5, 17]

Sage Live

P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
X.count_points(2)                                                     # needs sage.libs.singular sage.rings.finite_rings

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(4), 't'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)# needs sage.rings.finite_rings
>>> X = P.subscheme([y**Integer(2)*z - x**Integer(3) - z**Integer(3)])                                  # needs sage.rings.finite_rings
>>> X.count_points(Integer(2))                                                     # needs sage.libs.singular sage.rings.finite_rings
[5, 17]

Sage Live

P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
X.count_points(2)                                                     # needs sage.libs.singular sage.rings.finite_rings

dimension()[source]¶

Return the absolute dimension of this scheme.

OUTPUT: integer

EXAMPLES:

Sage

sage: R.<x, y> = QQ[]
sage: I = (x^2 - y^2)*R
sage: X = Spec(R.quotient(I))
sage: X.dimension_absolute()
Traceback (most recent call last):
...
NotImplementedError
sage: X.dimension()
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> R = QQ['x, y']; (x, y,) = R._first_ngens(2)
>>> I = (x**Integer(2) - y**Integer(2))*R
>>> X = Spec(R.quotient(I))
>>> X.dimension_absolute()
Traceback (most recent call last):
...
NotImplementedError
>>> X.dimension()
Traceback (most recent call last):
...
NotImplementedError

Sage Live

R.<x, y> = QQ[]
I = (x^2 - y^2)*R
X = Spec(R.quotient(I))
X.dimension_absolute()
X.dimension()

dimension_absolute()[source]¶

Return the absolute dimension of this scheme.

OUTPUT: integer

EXAMPLES:

Sage

sage: R.<x, y> = QQ[]
sage: I = (x^2 - y^2)*R
sage: X = Spec(R.quotient(I))
sage: X.dimension_absolute()
Traceback (most recent call last):
...
NotImplementedError
sage: X.dimension()
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> R = QQ['x, y']; (x, y,) = R._first_ngens(2)
>>> I = (x**Integer(2) - y**Integer(2))*R
>>> X = Spec(R.quotient(I))
>>> X.dimension_absolute()
Traceback (most recent call last):
...
NotImplementedError
>>> X.dimension()
Traceback (most recent call last):
...
NotImplementedError

Sage Live

R.<x, y> = QQ[]
I = (x^2 - y^2)*R
X = Spec(R.quotient(I))
X.dimension_absolute()
X.dimension()

dimension_relative()[source]¶

Return the relative dimension of this scheme over its base.

OUTPUT: integer

EXAMPLES:

Sage

sage: R.<x, y> = QQ[]
sage: I = (x^2 - y^2)*R
sage: X = Spec(R.quotient(I))
sage: X.dimension_relative()
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> R = QQ['x, y']; (x, y,) = R._first_ngens(2)
>>> I = (x**Integer(2) - y**Integer(2))*R
>>> X = Spec(R.quotient(I))
>>> X.dimension_relative()
Traceback (most recent call last):
...
NotImplementedError

Sage Live

R.<x, y> = QQ[]
I = (x^2 - y^2)*R
X = Spec(R.quotient(I))
X.dimension_relative()

hom(x, Y=None, check=True)[source]¶

Return the scheme morphism from self to Y defined by x.

INPUT:

x – anything that determines a scheme morphism; if x is a scheme, try to determine a natural map to x
Y – the codomain scheme (optional); if Y is not given, try to determine Y from context
check – boolean (default: True); whether to check the defining data for consistency

OUTPUT: the scheme morphism from self to Y defined by x

EXAMPLES:

Sage

sage: P = ProjectiveSpace(ZZ, 3)
sage: P.hom(Spec(ZZ))
Scheme morphism:
  From: Projective Space of dimension 3 over Integer Ring
  To:   Spectrum of Integer Ring
  Defn: Structure map

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(3))
>>> P.hom(Spec(ZZ))
Scheme morphism:
  From: Projective Space of dimension 3 over Integer Ring
  To:   Spectrum of Integer Ring
  Defn: Structure map

Sage Live

P = ProjectiveSpace(ZZ, 3)
P.hom(Spec(ZZ))

identity_morphism()[source]¶

Return the identity morphism.

OUTPUT: the identity morphism of the scheme self

EXAMPLES:

Sage

sage: X = Spec(QQ)
sage: X.identity_morphism()
Scheme endomorphism of Spectrum of Rational Field
  Defn: Identity map

Python

>>> from sage.all import *
>>> X = Spec(QQ)
>>> X.identity_morphism()
Scheme endomorphism of Spectrum of Rational Field
  Defn: Identity map

Sage Live

X = Spec(QQ)
X.identity_morphism()

point(v, check=True)[source]¶

Create a point.

INPUT:

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

OUTPUT: a point of the scheme

EXAMPLES:

Sage

sage: A2 = AffineSpace(QQ, 2)
sage: A2.point([4, 5])
(4, 5)

sage: R.<t> = PolynomialRing(QQ)
sage: E = EllipticCurve([t + 1, t, t, 0, 0])                                # needs sage.schemes
sage: E.point([0, 0])                                                       # needs sage.schemes
(0 : 0 : 1)

Python

>>> from sage.all import *
>>> A2 = AffineSpace(QQ, Integer(2))
>>> A2.point([Integer(4), Integer(5)])
(4, 5)

>>> R = PolynomialRing(QQ, names=('t',)); (t,) = R._first_ngens(1)
>>> E = EllipticCurve([t + Integer(1), t, t, Integer(0), Integer(0)])                                # needs sage.schemes
>>> E.point([Integer(0), Integer(0)])                                                       # needs sage.schemes
(0 : 0 : 1)

Sage Live

A2 = AffineSpace(QQ, 2)
A2.point([4, 5])
R.<t> = PolynomialRing(QQ)
E = EllipticCurve([t + 1, t, t, 0, 0])                                # needs sage.schemes
E.point([0, 0])                                                       # needs sage.schemes

point_homset(S=None)[source]¶

Return the set of S-valued points of this scheme.

INPUT:

S – a commutative ring

OUTPUT: the set of morphisms \(\mathrm{Spec}(S) \to X\)

EXAMPLES:

Sage

sage: P = ProjectiveSpace(ZZ, 3)
sage: P.point_homset(ZZ)
Set of rational points of Projective Space of dimension 3 over Integer Ring
sage: P.point_homset(QQ)
Set of rational points of Projective Space of dimension 3 over Rational Field
sage: P.point_homset(GF(11))
Set of rational points of Projective Space of dimension 3 over
 Finite Field of size 11

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(3))
>>> P.point_homset(ZZ)
Set of rational points of Projective Space of dimension 3 over Integer Ring
>>> P.point_homset(QQ)
Set of rational points of Projective Space of dimension 3 over Rational Field
>>> P.point_homset(GF(Integer(11)))
Set of rational points of Projective Space of dimension 3 over
 Finite Field of size 11

Sage Live

P = ProjectiveSpace(ZZ, 3)
P.point_homset(ZZ)
P.point_homset(QQ)
P.point_homset(GF(11))

point_set(S=None)[source]¶

Return the set of S-valued points of this scheme.

INPUT:

S – a commutative ring

OUTPUT: the set of morphisms \(\mathrm{Spec}(S) \to X\)

EXAMPLES:

Sage

sage: P = ProjectiveSpace(ZZ, 3)
sage: P.point_homset(ZZ)
Set of rational points of Projective Space of dimension 3 over Integer Ring
sage: P.point_homset(QQ)
Set of rational points of Projective Space of dimension 3 over Rational Field
sage: P.point_homset(GF(11))
Set of rational points of Projective Space of dimension 3 over
 Finite Field of size 11

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(ZZ, Integer(3))
>>> P.point_homset(ZZ)
Set of rational points of Projective Space of dimension 3 over Integer Ring
>>> P.point_homset(QQ)
Set of rational points of Projective Space of dimension 3 over Rational Field
>>> P.point_homset(GF(Integer(11)))
Set of rational points of Projective Space of dimension 3 over
 Finite Field of size 11

Sage Live

P = ProjectiveSpace(ZZ, 3)
P.point_homset(ZZ)
P.point_homset(QQ)
P.point_homset(GF(11))

structure_morphism()[source]¶

Return the structure morphism from self to its base scheme.

OUTPUT: a scheme morphism

EXAMPLES:

Sage

sage: A = AffineSpace(4, QQ)
sage: A.base_morphism()
Scheme morphism:
  From: Affine Space of dimension 4 over Rational Field
  To:   Spectrum of Rational Field
  Defn: Structure map

sage: X = Spec(QQ)
sage: X.base_morphism()
Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Structure map

Python

>>> from sage.all import *
>>> A = AffineSpace(Integer(4), QQ)
>>> A.base_morphism()
Scheme morphism:
  From: Affine Space of dimension 4 over Rational Field
  To:   Spectrum of Rational Field
  Defn: Structure map

>>> X = Spec(QQ)
>>> X.base_morphism()
Scheme morphism:
  From: Spectrum of Rational Field
  To:   Spectrum of Integer Ring
  Defn: Structure map

Sage Live

A = AffineSpace(4, QQ)
A.base_morphism()
X = Spec(QQ)
X.base_morphism()

union(X)[source]¶

Return the disjoint union of the schemes self and X.

EXAMPLES:

Sage

sage: S = Spec(QQ)
sage: X = AffineSpace(1, QQ)
sage: S.union(X)
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> S = Spec(QQ)
>>> X = AffineSpace(Integer(1), QQ)
>>> S.union(X)
Traceback (most recent call last):
...
NotImplementedError

Sage Live

S = Spec(QQ)
X = AffineSpace(1, QQ)
S.union(X)

zeta_function()[source]¶

Compute the zeta function of a generic scheme.

Derived classes should override this method.

OUTPUT: rational function in one variable

EXAMPLES:

Sage

sage: P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
sage: X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
sage: X.zeta_function()                                                     # needs sage.rings.finite_rings
Traceback (most recent call last):
...
NotImplementedError

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(4), 't'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)# needs sage.rings.finite_rings
>>> X = P.subscheme([y**Integer(2)*z - x**Integer(3) - z**Integer(3)])                                  # needs sage.rings.finite_rings
>>> X.zeta_function()                                                     # needs sage.rings.finite_rings
Traceback (most recent call last):
...
NotImplementedError

Sage Live

P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
X.zeta_function()                                                     # needs sage.rings.finite_rings

zeta_series(n, t)[source]¶

Return the zeta series.

Compute a power series approximation to the zeta function of a scheme over a finite field.

INPUT:

n – the number of terms of the power series to compute
t – the variable which the series should be returned

OUTPUT: a power series approximating the zeta function of self

EXAMPLES:

Sage

sage: P.<x> = PolynomialRing(GF(3))
sage: C = HyperellipticCurve(x^3 + x^2 + 1)                                 # needs sage.schemes
sage: R.<t> = PowerSeriesRing(Integers())
sage: C.zeta_series(4, t)                                                   # needs sage.schemes
1 + 6*t + 24*t^2 + 78*t^3 + 240*t^4 + O(t^5)
sage: (1+2*t+3*t^2)/(1-t)/(1-3*t) + O(t^5)
1 + 6*t + 24*t^2 + 78*t^3 + 240*t^4 + O(t^5)

Python

>>> from sage.all import *
>>> P = PolynomialRing(GF(Integer(3)), names=('x',)); (x,) = P._first_ngens(1)
>>> C = HyperellipticCurve(x**Integer(3) + x**Integer(2) + Integer(1))                                 # needs sage.schemes
>>> R = PowerSeriesRing(Integers(), names=('t',)); (t,) = R._first_ngens(1)
>>> C.zeta_series(Integer(4), t)                                                   # needs sage.schemes
1 + 6*t + 24*t^2 + 78*t^3 + 240*t^4 + O(t^5)
>>> (Integer(1)+Integer(2)*t+Integer(3)*t**Integer(2))/(Integer(1)-t)/(Integer(1)-Integer(3)*t) + O(t**Integer(5))
1 + 6*t + 24*t^2 + 78*t^3 + 240*t^4 + O(t^5)

Sage Live

P.<x> = PolynomialRing(GF(3))
C = HyperellipticCurve(x^3 + x^2 + 1)                                 # needs sage.schemes
R.<t> = PowerSeriesRing(Integers())
C.zeta_series(4, t)                                                   # needs sage.schemes
(1+2*t+3*t^2)/(1-t)/(1-3*t) + O(t^5)

If the scheme has a method zeta_function, this is used to provide the required approximation. Otherwise this function depends on count_points, which is only defined for prime order fields for general schemes. Nonetheless, since Issue #15108 and Issue #15148, it supports hyperelliptic curves over non-prime fields:

Sage

sage: C.base_extend(GF(9, 'a')).zeta_series(4, t)                           # needs sage.rings.finite_rings sage.schemes
1 + 12*t + 120*t^2 + 1092*t^3 + 9840*t^4 + O(t^5)

Python

>>> from sage.all import *
>>> C.base_extend(GF(Integer(9), 'a')).zeta_series(Integer(4), t)                           # needs sage.rings.finite_rings sage.schemes
1 + 12*t + 120*t^2 + 1092*t^3 + 9840*t^4 + O(t^5)

Sage Live

C.base_extend(GF(9, 'a')).zeta_series(4, t)                           # needs sage.rings.finite_rings sage.schemes

Sage

sage: P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
sage: X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings

sage: R.<t> = PowerSeriesRing(Integers())
sage: X.zeta_series(2, t)                                                   # needs sage.libs.singular sage.rings.finite_rings
1 + 5*t + 21*t^2 + O(t^3)

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(4), 't'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)# needs sage.rings.finite_rings
>>> X = P.subscheme([y**Integer(2)*z - x**Integer(3) - z**Integer(3)])                                  # needs sage.rings.finite_rings

>>> R = PowerSeriesRing(Integers(), names=('t',)); (t,) = R._first_ngens(1)
>>> X.zeta_series(Integer(2), t)                                                   # needs sage.libs.singular sage.rings.finite_rings
1 + 5*t + 21*t^2 + O(t^3)

Sage Live

P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
R.<t> = PowerSeriesRing(Integers())
X.zeta_series(2, t)                                                   # needs sage.libs.singular sage.rings.finite_rings

Python

>>> from sage.all import *
>>> P = ProjectiveSpace(GF(Integer(4), 't'), Integer(2), names=('x', 'y', 'z',)); (x, y, z,) = P._first_ngens(3)# needs sage.rings.finite_rings
>>> X = P.subscheme([y**Integer(2)*z - x**Integer(3) - z**Integer(3)])                                  # needs sage.rings.finite_rings

>>> R = PowerSeriesRing(Integers(), names=('t',)); (t,) = R._first_ngens(1)
>>> X.zeta_series(Integer(2), t)                                                   # needs sage.libs.singular sage.rings.finite_rings
1 + 5*t + 21*t^2 + O(t^3)

Sage Live

P.<x,y,z> = ProjectiveSpace(GF(4, 't'), 2)                            # needs sage.rings.finite_rings
X = P.subscheme([y^2*z - x^3 - z^3])                                  # needs sage.rings.finite_rings
R.<t> = PowerSeriesRing(Integers())
X.zeta_series(2, t)                                                   # needs sage.libs.singular sage.rings.finite_rings

sage.schemes.generic.scheme.is_AffineScheme(x)[source]¶

Return True if \(x\) is an affine scheme.

EXAMPLES:

Sage

sage: from sage.schemes.generic.scheme import is_AffineScheme
sage: is_AffineScheme(5)
doctest:warning...
DeprecationWarning: The function is_AffineScheme is deprecated; use 'isinstance(..., AffineScheme)' instead.
See https://github.com/sagemath/sage/issues/38022 for details.
False
sage: E = Spec(QQ)
sage: is_AffineScheme(E)
True

Python

>>> from sage.all import *
>>> from sage.schemes.generic.scheme import is_AffineScheme
>>> is_AffineScheme(Integer(5))
doctest:warning...
DeprecationWarning: The function is_AffineScheme is deprecated; use 'isinstance(..., AffineScheme)' instead.
See https://github.com/sagemath/sage/issues/38022 for details.
False
>>> E = Spec(QQ)
>>> is_AffineScheme(E)
True

Sage Live

from sage.schemes.generic.scheme import is_AffineScheme
is_AffineScheme(5)
E = Spec(QQ)
is_AffineScheme(E)

sage.schemes.generic.scheme.is_Scheme(x)[source]¶

Test whether x is a scheme.

INPUT:

x – anything

OUTPUT: boolean; whether x derives from Scheme

EXAMPLES:

Sage

sage: from sage.schemes.generic.scheme import is_Scheme
sage: is_Scheme(5)
doctest:warning...
DeprecationWarning: The function is_Scheme is deprecated; use 'isinstance(..., Scheme)' or categories instead.
See https://github.com/sagemath/sage/issues/38022 for details.
False
sage: X = Spec(QQ)
sage: is_Scheme(X)
True

Python

>>> from sage.all import *
>>> from sage.schemes.generic.scheme import is_Scheme
>>> is_Scheme(Integer(5))
doctest:warning...
DeprecationWarning: The function is_Scheme is deprecated; use 'isinstance(..., Scheme)' or categories instead.
See https://github.com/sagemath/sage/issues/38022 for details.
False
>>> X = Spec(QQ)
>>> is_Scheme(X)
True

Sage Live

from sage.schemes.generic.scheme import is_Scheme
is_Scheme(5)
X = Spec(QQ)
is_Scheme(X)