Set of homomorphisms between two schemes#

For schemes \(X\) and \(Y\), this module implements the set of morphisms \(Hom(X,Y)\). This is done by SchemeHomset_generic.

As a special case, the Hom-sets can also represent the points of a scheme. Recall that the \(K\)-rational points of a scheme \(X\) over \(k\) can be identified with the set of morphisms \(Spec(K) \to X\). In Sage the rational points are implemented by such scheme morphisms. This is done by SchemeHomset_points and its subclasses.

Note

You should not create the Hom-sets manually. Instead, use the Hom() method that is inherited by all schemes.

AUTHORS:

  • William Stein (2006): initial version.

  • Volker Braun (2011-08-11): significant improvement and refactoring.

  • Ben Hutz (June 2012): added support for projective ring

class sage.schemes.generic.homset.SchemeHomsetFactory#

Bases: UniqueFactory

Factory for Hom-sets of schemes.

EXAMPLES:

sage: A2 = AffineSpace(QQ, 2)
sage: A3 = AffineSpace(QQ, 3)
sage: Hom = A3.Hom(A2)

The Hom-sets are uniquely determined by domain and codomain:

sage: Hom is copy(Hom)
True
sage: Hom is A3.Hom(A2)
True

The Hom-sets are identical if the domains and codomains are identical:

sage: loads(Hom.dumps()) is Hom
True
sage: A3_iso = AffineSpace(QQ, 3)
sage: A3_iso is A3
True
sage: Hom_iso = A3_iso.Hom(A2)
sage: Hom_iso is Hom
True
create_key_and_extra_args(X, Y, category=None, base=None, check=True, as_point_homset=False)#

Create a key that uniquely determines the Hom-set.

INPUT:

  • X – a scheme. The domain of the morphisms.

  • Y – a scheme. The codomain of the morphisms.

  • category – a category for the Hom-sets (default: schemes over given base).

  • base – a scheme or a ring. The base scheme of domain and codomain schemes. If a ring is specified, the spectrum of that ring will be used as base scheme.

  • check – boolean (default: True).

EXAMPLES:

sage: A2 = AffineSpace(QQ, 2)
sage: A3 = AffineSpace(QQ, 3)
sage: A3.Hom(A2)    # indirect doctest
Set of morphisms
  From: Affine Space of dimension 3 over Rational Field
  To:   Affine Space of dimension 2 over Rational Field
sage: from sage.schemes.generic.homset import SchemeHomsetFactory
sage: SHOMfactory = SchemeHomsetFactory('test')
sage: key, extra = SHOMfactory.create_key_and_extra_args(A3, A2, check=False)
sage: key
(..., ..., Category of schemes over Rational Field, False)
sage: extra
{'X': Affine Space of dimension 3 over Rational Field,
 'Y': Affine Space of dimension 2 over Rational Field,
 'base_ring': Rational Field,
 'check': False}
create_object(version, key, **extra_args)#

Create a SchemeHomset_generic.

INPUT:

  • version – object version. Currently not used.

  • key – a key created by create_key_and_extra_args().

  • extra_args – a dictionary of extra keyword arguments.

EXAMPLES:

sage: A2 = AffineSpace(QQ, 2)
sage: A3 = AffineSpace(QQ, 3)
sage: A3.Hom(A2) is A3.Hom(A2)   # indirect doctest
True
sage: from sage.schemes.generic.homset import SchemeHomsetFactory
sage: SHOMfactory = SchemeHomsetFactory('test')
sage: SHOMfactory.create_object(0, [id(A3), id(A2), A3.category(), False],
....:                           check=True, X=A3, Y=A2, base_ring=QQ)
Set of morphisms
  From: Affine Space of dimension 3 over Rational Field
  To:   Affine Space of dimension 2 over Rational Field
class sage.schemes.generic.homset.SchemeHomset_generic(X, Y, category=None, check=True, base=None)#

Bases: HomsetWithBase

The base class for Hom-sets of schemes.

INPUT:

  • X – a scheme. The domain of the Hom-set.

  • Y – a scheme. The codomain of the Hom-set.

  • category – a category (optional). The category of the Hom-set.

  • check – boolean (optional, default: True). Whether to check the defining data for consistency.

EXAMPLES:

sage: from sage.schemes.generic.homset import SchemeHomset_generic
sage: A2 = AffineSpace(QQ,2)
sage: Hom = SchemeHomset_generic(A2, A2); Hom
Set of morphisms
  From: Affine Space of dimension 2 over Rational Field
  To:   Affine Space of dimension 2 over Rational Field
sage: Hom.category()
Category of endsets of schemes over Rational Field
Element#

alias of SchemeMorphism

natural_map()#

Return a natural map in the Hom space.

OUTPUT:

A SchemeMorphism if there is a natural map from domain to codomain. Otherwise, a NotImplementedError is raised.

EXAMPLES:

sage: A = AffineSpace(4, QQ)
sage: A.structure_morphism()   # indirect doctest
Scheme morphism:
  From: Affine Space of dimension 4 over Rational Field
  To:   Spectrum of Rational Field
  Defn: Structure map
class sage.schemes.generic.homset.SchemeHomset_points(X, Y, category=None, check=True, base=Integer Ring)#

Bases: SchemeHomset_generic

Set of rational points of the scheme.

Recall that the \(K\)-rational points of a scheme \(X\) over \(k\) can be identified with the set of morphisms \(Spec(K) o X\). In Sage, the rational points are implemented by such scheme morphisms.

If a scheme has a finite number of points, then the homset is supposed to implement the Python iterator interface. See SchemeHomset_points_toric_field for example.

INPUT:

See SchemeHomset_generic.

EXAMPLES:

sage: from sage.schemes.generic.homset import SchemeHomset_points
sage: SchemeHomset_points(Spec(QQ), AffineSpace(ZZ,2))
Set of rational points of Affine Space of dimension 2 over Rational Field
cardinality()#

Return the number of points.

OUTPUT:

An integer or infinity.

EXAMPLES:

sage: toric_varieties.P2().point_set().cardinality()
+Infinity

sage: P2 = toric_varieties.P2(base_ring=GF(3))                              # optional - sage.rings.finite_rings
sage: P2.point_set().cardinality()                                          # optional - sage.rings.finite_rings
13
extended_codomain()#

Return the codomain with extended base, if necessary.

OUTPUT:

The codomain scheme, with its base ring extended to the codomain. That is, the codomain is of the form \(Spec(R)\) and the base ring of the domain is extended to \(R\).

EXAMPLES:

sage: P2 = ProjectiveSpace(QQ, 2)
sage: x = polygen(ZZ, 'x')
sage: K.<a> = NumberField(x^2 + x - (3^3-3))                                # optional - sage.rings.number_field
sage: K_points = P2(K);  K_points                                           # optional - sage.rings.number_field
Set of rational points of Projective Space of dimension 2
 over Number Field in a with defining polynomial x^2 + x - 24

sage: K_points.codomain()                                                   # optional - sage.rings.number_field
Projective Space of dimension 2 over Rational Field

sage: K_points.extended_codomain()                                          # optional - sage.rings.number_field
Projective Space of dimension 2
 over Number Field in a with defining polynomial x^2 + x - 24
list()#

Return a tuple containing all points.

OUTPUT:

A tuple containing all points of the toric variety.

EXAMPLES:

sage: P1 = toric_varieties.P1(base_ring=GF(3))                              # optional - sage.rings.finite_rings
sage: P1.point_set().list()                                                 # optional - sage.rings.finite_rings
([0 : 1], [1 : 0], [1 : 1], [1 : 2])
value_ring()#

Return \(R\) for a point Hom-set \(X(Spec(R))\).

OUTPUT:

A commutative ring.

EXAMPLES:

sage: P2 = ProjectiveSpace(ZZ, 2)
sage: P2(QQ).value_ring()
Rational Field
sage.schemes.generic.homset.is_SchemeHomset(H)#

Test whether H is a scheme Hom-set.

EXAMPLES:

sage: f = Spec(QQ).identity_morphism();  f
Scheme endomorphism of Spectrum of Rational Field
  Defn: Identity map
sage: from sage.schemes.generic.homset import is_SchemeHomset
sage: is_SchemeHomset(f)
False
sage: is_SchemeHomset(f.parent())
True
sage: is_SchemeHomset('a string')
False