def create_key_and_extra_args(self, X, Y, category=None, base=ZZ,
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 Integer Ring, False)
sage: extra
{'X': Affine Space of dimension 3 over Rational Field,
'Y': Affine Space of dimension 2 over Rational Field,
'base_ring': Integer Ring,
'check': False}
"""
if isinstance(X, CommutativeRing):
X = AffineScheme(X)
if isinstance(Y, CommutativeRing):
Y = AffineScheme(Y)
if is_AffineScheme(base):
base_spec = base
base_ring = base.coordinate_ring()
elif isinstance(base, CommutativeRing):
base_spec = AffineScheme(base)
base_ring = base
else:
raise ValueError('base must be a commutative ring or its spectrum')
if not category:
from sage.categories.schemes import Schemes
category = Schemes(base_spec)
key = tuple([id(X), id(Y), category, as_point_homset])
extra = {'X':X, 'Y':Y, 'base_ring':base_ring, 'check':check}
return key, extra
def create_key_and_extra_args(self, X, Y, category=None, base=ZZ,
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 Integer Ring, False)
sage: extra
{'X': Affine Space of dimension 3 over Rational Field,
'Y': Affine Space of dimension 2 over Rational Field,
'base_ring': Integer Ring,
'check': False}
"""
if isinstance(X, CommutativeRing):
X = AffineScheme(X)
if isinstance(Y, CommutativeRing):
Y = AffineScheme(Y)
if is_AffineScheme(base):
base_spec = base
base_ring = base.coordinate_ring()
elif isinstance(base, CommutativeRing):
base_spec = AffineScheme(base)
base_ring = base
else:
raise ValueError('base must be a commutative ring or its spectrum')
if not category:
from sage.categories.schemes import Schemes
category = Schemes(base_spec)
key = tuple([id(X), id(Y), category, as_point_homset])
extra = {'X':X, 'Y':Y, 'base_ring':base_ring, 'check':check}
return key, extra
def value_ring(self):
"""
Returns S for a homset X(T) where T = Spec(S).
"""
from sage.schemes.generic.scheme import is_AffineScheme
T = self.domain()
if is_AffineScheme(T):
return T.coordinate_ring()
else:
raise TypeError("Domain of argument must be of the form Spec(S).")
def value_ring(self):
"""
Returns S for a homset X(T) where T = Spec(S).
"""
from sage.schemes.generic.scheme import is_AffineScheme
T = self.domain()
if is_AffineScheme(T):
return T.coordinate_ring()
else:
raise TypeError("Domain of argument must be of the form Spec(S).")
def _repr_object_names(self):
"""
EXAMPLES::
sage: Schemes(Spec(ZZ)) # indirect doctest
Category of schemes over Integer Ring
"""
# To work around the name of the class (schemes_over_base)
from sage.schemes.generic.scheme import is_AffineScheme
if is_AffineScheme(self.base_scheme()):
return "schemes over %s" % self.base_scheme().coordinate_ring()
else:
return "schemes over %s" % self.base_scheme()
def __init__(self, X, Y, category=None, check=True, base=ZZ):
"""
Python constructor.
INPUT:
See :class:`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
"""
if check and not is_AffineScheme(X):
raise ValueError('The domain must be an affine scheme.')
SchemeHomset_generic.__init__(self, X, Y, category=category, check=check, base=base)
def __init__(self, X, Y, category=None, check=True, base=ZZ):
"""
Python constructor.
INPUT:
See :class:`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
"""
if check and not is_AffineScheme(X):
raise ValueError('The domain must be an affine scheme.')
SchemeHomset_generic.__init__(self, X, Y, category=category, check=check, base=base)
def value_ring(self):
"""
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
"""
dom = self.domain()
if not is_AffineScheme(dom):
raise ValueError("value rings are defined for affine domains only")
return dom.coordinate_ring()
def value_ring(self):
"""
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
"""
dom = self.domain()
if not is_AffineScheme(dom):
raise ValueError("value rings are defined for affine domains only")
return dom.coordinate_ring()
def natural_map(self):
r"""
Return a natural map in the Hom space.
OUTPUT:
A :class:`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
"""
X = self.domain()
Y = self.codomain()
if is_AffineScheme(Y) and Y.coordinate_ring() == X.base_ring():
return SchemeMorphism_structure_map(self)
raise NotImplementedError
def natural_map(self):
r"""
Return a natural map in the Hom space.
OUTPUT:
A :class:`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
"""
X = self.domain()
Y = self.codomain()
if is_AffineScheme(Y) and Y.coordinate_ring() == X.base_ring():
return SchemeMorphism_structure_map(self)
raise NotImplementedError
