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))