def create_key_and_extra_args(self, X, Y, category=None, base=ZZ,
check=True):
"""
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)
sage: extra
{'Y': Affine Space of dimension 2 over Rational Field,
'X': Affine Space of dimension 3 over Rational Field,
'base_ring': Integer Ring, 'check': False}
"""
if not is_Scheme(X) and is_CommutativeRing(X):
X = Spec(X)
if not is_Scheme(Y) and is_CommutativeRing(Y):
Y = Spec(Y)
if is_Spec(base):
base_spec = base
base_ring = base.coordinate_ring()
elif is_CommutativeRing(base):
base_spec = Spec(base)
base_ring = base
else:
raise ValueError(
'The 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])
extra = {'X':X, 'Y':Y, 'base_ring':base_ring, 'check':check}
return key, extra
def base_scheme(self):
"""
Return the base scheme.
OUTPUT:
A scheme.
EXAMPLES::
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
"""
try:
return self._base_scheme
except AttributeError:
if hasattr(self, '_base_morphism'):
self._base_scheme = self._base_morphism.codomain()
elif hasattr(self, '_base_ring'):
from sage.schemes.generic.spec import Spec
self._base_scheme = Spec(self._base_ring)
else:
from sage.schemes.generic.spec import SpecZ
self._base_scheme = SpecZ
return self._base_scheme
def canonical_scheme(self, t=None):
"""
Return the canonical scheme.
This is a scheme that contains this hypergeometric motive in its cohomology.
EXAMPLES::
sage: from sage.modular.hypergeometric_motive import HypergeometricData as Hyp
sage: H = Hyp(cyclotomic=([3],[4]))
sage: H.gamma_list()
[-1, 2, 3, -4]
sage: H.canonical_scheme()
Spectrum of Quotient of Multivariate Polynomial Ring
in X0, X1, Y0, Y1 over Fraction Field of Univariate Polynomial Ring
in t over Rational Field by the ideal
(X0 + X1 - 1, Y0 + Y1 - 1, (-t)*X0^2*X1^3 + 27/64*Y0*Y1^4)
sage: H = Hyp(gamma_list=[-2, 3, 4, -5])
sage: H.canonical_scheme()
Spectrum of Quotient of Multivariate Polynomial Ring
in X0, X1, Y0, Y1 over Fraction Field of Univariate Polynomial Ring
in t over Rational Field by the ideal
(X0 + X1 - 1, Y0 + Y1 - 1, (-t)*X0^3*X1^4 + 1728/3125*Y0^2*Y1^5)
REFERENCES:
[Kat1991]_, section 5.4
"""
if t is None:
t = FractionField(QQ['t']).gen()
basering = t.parent()
gamma_pos = [u for u in self.gamma_list() if u > 0]
gamma_neg = [u for u in self.gamma_list() if u < 0]
N_pos = len(gamma_pos)
N_neg = len(gamma_neg)
varX = ['X{}'.format(i) for i in range(N_pos)]
varY = ['Y{}'.format(i) for i in range(N_neg)]
ring = PolynomialRing(basering, varX + varY)
gens = ring.gens()
X = gens[:N_pos]
Y = gens[N_pos:]
eq0 = ring.sum(X) - 1
eq1 = ring.sum(Y) - 1
eq2_pos = ring.prod(X[i] ** gamma_pos[i] for i in range(N_pos))
eq2_neg = ring.prod(Y[j] ** -gamma_neg[j] for j in range(N_neg))
ideal = ring.ideal([eq0, eq1, self.M_value() * eq2_neg - t * eq2_pos])
return Spec(ring.quotient(ideal))
def base_morphism(self):
"""
Return the structure morphism from ``self`` to its base
scheme.
OUTPUT:
A scheme morphism.
EXAMPLES::
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
"""
try:
return self._base_morphism
except AttributeError:
from sage.categories.schemes import Schemes
from sage.schemes.generic.spec import Spec, SpecZ
SCH = Schemes()
if hasattr(self, '_base_scheme'):
self._base_morphism = self.Hom(self._base_scheme,
category=SCH).natural_map()
elif hasattr(self, '_base_ring'):
self._base_morphism = self.Hom(Spec(self._base_ring),
category=SCH).natural_map()
else:
self._base_morphism = self.Hom(SpecZ,
category=SCH).natural_map()
return self._base_morphism
def point_homset(self, S=None):
"""
Return the set of S-valued points of this scheme.
INPUT:
- ``S`` -- a commutative ring.
OUTPUT:
The set of morphisms `Spec(S)\to X`.
EXAMPLES::
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
TESTS::
sage: P = ProjectiveSpace(QQ,3)
sage: P.point_homset(GF(11))
Traceback (most recent call last):
...
ValueError: There must be a natural map S --> R, but
S = Rational Field and R = Finite Field of size 11
"""
if S is None:
S = self.base_ring()
from sage.schemes.generic.spec import Spec
SpecS = Spec(S, self.base_ring())
from sage.schemes.generic.homset import SchemeHomset
return SchemeHomset(SpecS, self)
def _call_(self, x):
"""
Construct a scheme from the data in ``x``
EXAMPLES:
Let us first construct the category of schemes::
sage: S = Schemes(); S
Category of schemes
We create a scheme from a ring::
sage: X = S(ZZ); X # indirect doctest
Spectrum of Integer Ring
We create a scheme from a scheme (do nothing)::
sage: S(X)
Spectrum of Integer Ring
We create a scheme morphism from a ring homomorphism.x::
sage: phi = ZZ.hom(QQ); phi
Ring Coercion morphism:
From: Integer Ring
To: Rational Field
sage: f = S(phi); f # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Ring Coercion morphism:
From: Integer Ring
To: Rational Field
sage: f.domain()
Spectrum of Rational Field
sage: f.codomain()
Spectrum of Integer Ring
sage: S(f) # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Ring Coercion morphism:
From: Integer Ring
To: Rational Field
"""
from sage.schemes.generic.scheme import is_Scheme
if is_Scheme(x):
return x
from sage.schemes.generic.morphism import is_SchemeMorphism
if is_SchemeMorphism(x):
return x
from sage.rings.morphism import is_RingHomomorphism
from sage.rings.commutative_ring import is_CommutativeRing
from sage.schemes.generic.spec import Spec
if is_CommutativeRing(x):
return Spec(x)
elif is_RingHomomorphism(x):
A = Spec(x.codomain())
return A.hom(x)
else:
raise TypeError(
"No way to create an object or morphism in %s from %s" %
(self, x))
def _call_(self, x):
"""
Construct a scheme from the data in ``x``
EXAMPLES:
Let us first construct the category of schemes::
sage: S = Schemes(); S
Category of schemes
We create a scheme from a ring::
sage: X = S(ZZ); X # indirect doctest
Spectrum of Integer Ring
We create a scheme from a scheme (do nothing)::
sage: S(X)
Spectrum of Integer Ring
We create a scheme morphism from a ring homomorphism.x::
sage: phi = ZZ.hom(QQ); phi
Ring Coercion morphism:
From: Integer Ring
To: Rational Field
sage: f = S(phi); f # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Ring Coercion morphism:
From: Integer Ring
To: Rational Field
sage: f.domain()
Spectrum of Rational Field
sage: f.codomain()
Spectrum of Integer Ring
sage: S(f) # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Ring Coercion morphism:
From: Integer Ring
To: Rational Field
"""
from sage.schemes.generic.scheme import is_Scheme
if is_Scheme(x):
return x
from sage.schemes.generic.morphism import is_SchemeMorphism
if is_SchemeMorphism(x):
return x
from sage.rings.morphism import is_RingHomomorphism
from sage.rings.ring import CommutativeRing
from sage.schemes.generic.spec import Spec
if isinstance(x, CommutativeRing):
return Spec(x)
elif is_RingHomomorphism(x):
A = Spec(x.codomain())
return A.hom(x)
else:
raise TypeError("No way to create an object or morphism in %s from %s"%(self, x))
def _call_(self, x):
"""
Construct a scheme from the data in ``x``
EXAMPLES:
Let us first construct the category of schemes::
sage: S = Schemes(); S
Category of schemes
We create a scheme from a ring::
sage: X = S(ZZ); X # indirect doctest
Spectrum of Integer Ring
We create a scheme from a scheme (do nothing)::
sage: S(X)
Spectrum of Integer Ring
We create a scheme morphism from a ring homomorphism.x::
sage: phi = ZZ.hom(QQ); phi
Natural morphism:
From: Integer Ring
To: Rational Field
sage: f = S(phi); f # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Natural morphism:
From: Integer Ring
To: Rational Field
sage: f.domain()
Spectrum of Rational Field
sage: f.codomain()
Spectrum of Integer Ring
sage: S(f) # indirect doctest
Affine Scheme morphism:
From: Spectrum of Rational Field
To: Spectrum of Integer Ring
Defn: Natural morphism:
From: Integer Ring
To: Rational Field
"""
from sage.schemes.generic.scheme import is_Scheme
if is_Scheme(x):
return x
from sage.schemes.generic.morphism import is_SchemeMorphism
if is_SchemeMorphism(x):
return x
from sage.rings.ring import CommutativeRing
from sage.schemes.generic.spec import Spec
from sage.categories.map import Map
from sage.categories.all import Rings
if isinstance(x, CommutativeRing):
return Spec(x)
elif isinstance(x, Map) and x.category_for().is_subcategory(Rings()):
# x is a morphism of Rings
A = Spec(x.codomain())
return A.hom(x)
else:
raise TypeError("No way to create an object or morphism in %s from %s"%(self, x))
