def A(self, n, names='z+', base_ring=QQ): r""" Construct the ``n``-dimensional affine space. INPUT: - ``n`` -- positive integer. The dimension of the affine space. - ``names`` -- string. Names for the homogeneous coordinates. See :func:`~sage.schemes.toric.variety.normalize_names` for acceptable formats. - ``base_ring`` -- a ring (default: `\QQ`). The base ring for the toric variety. OUTPUT: A :class:`toric variety <sage.schemes.toric.variety.ToricVariety_field>`. EXAMPLES:: sage: A3 = toric_varieties.A(3) sage: A3 3-d affine toric variety sage: A3.fan().rays() N(1, 0, 0), N(0, 1, 0), N(0, 0, 1) in 3-d lattice N sage: A3.gens() (z0, z1, z2) """ # We are going to eventually switch off consistency checks, so we need # to be sure that the input is acceptable. try: n = ZZ(n) # make sure that we got a "mathematical" integer except TypeError: raise TypeError("dimension of the affine space must be a " "positive integer!\nGot: %s" % n) if n <= 0: raise ValueError("only affine spaces of positive dimension can " "be constructed!\nGot: %s" % n) rays = identity_matrix(n).columns() cones = [list(range(n))] fan = Fan(cones, rays, check=self._check) return ToricVariety(fan, coordinate_names=names)
def torus(self, n, names='z+', base_ring=QQ): r""" Construct the ``n``-dimensional algebraic torus `(\mathbb{F}^\times)^n`. INPUT: - ``n`` -- non-negative integer. The dimension of the algebraic torus. - ``names`` -- string. Names for the homogeneous coordinates. See :func:`~sage.schemes.toric.variety.normalize_names` for acceptable formats. - ``base_ring`` -- a ring (default: `\QQ`). The base ring for the toric variety. OUTPUT: A :class:`toric variety <sage.schemes.toric.variety.ToricVariety_field>`. EXAMPLES:: sage: T3 = toric_varieties.torus(3); T3 3-d affine toric variety sage: T3.fan().rays() Empty collection in 3-d lattice N sage: T3.fan().virtual_rays() N(1, 0, 0), N(0, 1, 0), N(0, 0, 1) in 3-d lattice N sage: T3.gens() (z0, z1, z2) sage: sorted(T3.change_ring(GF(3)).point_set().list()) [[1 : 1 : 1], [1 : 1 : 2], [1 : 2 : 1], [1 : 2 : 2], [2 : 1 : 1], [2 : 1 : 2], [2 : 2 : 1], [2 : 2 : 2]] """ try: n = ZZ(n) except TypeError: raise TypeError('dimension of the torus must be an integer') if n < 0: raise ValueError('dimension must be non-negative') N = ToricLattice(n) fan = Fan([], lattice=N) return ToricVariety(fan, coordinate_names=names, base_field=base_ring)
def _make_ToricVariety(self, name, coordinate_names, base_ring): r""" Construct a toric variety and cache the result. INPUT: - ``name`` -- string. One of the pre-defined names in the ``toric_varieties_rays_cones`` data structure. - ``coordinate_names`` -- A string describing the names of the homogeneous coordinates of the toric variety. - ``base_ring`` -- a ring (default: `\QQ`). The base ring for the toric variety. OUTPUT: A :class:`toric variety <sage.schemes.toric.variety.ToricVariety_field>`. EXAMPLES:: sage: toric_varieties.A1() # indirect doctest 1-d affine toric variety """ rays, cones = toric_varieties_rays_cones[name] if coordinate_names is None: dict_key = (name, base_ring) else: coordinate_names = normalize_names(coordinate_names, len(rays), DEFAULT_PREFIX) dict_key = (name, base_ring) + tuple(coordinate_names) if dict_key not in self.__dict__: fan = Fan(cones, rays, check=self._check) self.__dict__[dict_key] = \ ToricVariety(fan, coordinate_names=coordinate_names, base_ring=base_ring) return self.__dict__[dict_key]
def Cube_deformation(self, k, names=None, base_ring=QQ): r""" Construct, for each `k\in\ZZ_{\geq 0}`, a toric variety with `\ZZ_k`-torsion in the Chow group. The fans of this sequence of toric varieties all equal the face fan of a unit cube topologically, but the ``(1,1,1)``-vertex is moved to ``(1,1,2k+1)``. This example was studied in [FS1994]_. INPUT: - ``k`` -- integer. The case ``k=0`` is the same as :meth:`Cube_face_fan`. - ``names`` -- string. Names for the homogeneous coordinates. See :func:`~sage.schemes.toric.variety.normalize_names` for acceptable formats. - ``base_ring`` -- a ring (default: `\QQ`). The base ring for the toric variety. OUTPUT: A :class:`toric variety <sage.schemes.toric.variety.ToricVariety_field>` `X_k`. Its Chow group is `A_1(X_k)=\ZZ_k`. EXAMPLES:: sage: X_2 = toric_varieties.Cube_deformation(2) sage: X_2 3-d toric variety covered by 6 affine patches sage: X_2.fan().rays() N( 1, 1, 5), N( 1, -1, 1), N(-1, 1, 1), N(-1, -1, 1), N(-1, -1, -1), N(-1, 1, -1), N( 1, -1, -1), N( 1, 1, -1) in 3-d lattice N sage: X_2.gens() (z0, z1, z2, z3, z4, z5, z6, z7) """ # We are going to eventually switch off consistency checks, so we need # to be sure that the input is acceptable. try: k = ZZ(k) # make sure that we got a "mathematical" integer except TypeError: raise TypeError("cube deformations X_k are defined only for " "non-negative integer k!\nGot: %s" % k) if k < 0: raise ValueError("cube deformations X_k are defined only for " "non-negative k!\nGot: %s" % k) rays = lambda kappa: matrix([[1, 1, 2 * kappa + 1], [1, -1, 1], [-1, 1, 1], [-1, -1, 1], [-1, -1, -1], [-1, 1, -1], [1, -1, -1], [1, 1, -1]]) cones = [[0, 1, 2, 3], [4, 5, 6, 7], [0, 1, 7, 6], [4, 5, 3, 2], [0, 2, 5, 7], [4, 6, 1, 3]] fan = Fan(cones, rays(k)) return ToricVariety(fan, coordinate_names=names)
def WP(self, *q, **kw): # Specific keyword arguments instead of **kw would be preferable, # later versions of Python might support specific (optional) keyword # arguments after *q. r""" Construct weighted projective `n`-space over a field. INPUT: - ``q`` -- a sequence of positive integers relatively prime to one another. The weights ``q`` can be given either as a list or tuple, or as positional arguments. Two keyword arguments: - ``base_ring`` -- a field (default: `\QQ`). - ``names`` -- string or list (tuple) of strings (default 'z+'). See :func:`~sage.schemes.toric.variety.normalize_names` for acceptable formats. OUTPUT: - A :class:`toric variety <sage.schemes.toric.variety.ToricVariety_field>`. If `q=(q_0,\dots,q_n)`, then the output is the weighted projective space `\mathbb{P}(q_0,\dots,q_n)` over ``base_ring``. ``names`` are the names of the generators of the homogeneous coordinate ring. EXAMPLES: A hyperelliptic curve `C` of genus 2 as a subscheme of the weighted projective plane `\mathbb{P}(1,3,1)`:: sage: X = toric_varieties.WP([1,3,1], names='x y z') sage: X.inject_variables() Defining x, y, z sage: g = y^2-(x^6-z^6) sage: C = X.subscheme([g]); C Closed subscheme of 2-d toric variety covered by 3 affine patches defined by: -x^6 + z^6 + y^2 """ if len(q) == 1: # tuples and lists of weights are acceptable input if isinstance(q[0], (list, tuple)): q = q[0] q = list(q) m = len(q) # allow case q=[1]? (not allowed presently) if m < 2: raise ValueError("more than one weight must be provided (got %s)" % q) for i in range(m): try: q[i] = ZZ(q[i]) except (TypeError): raise TypeError("the weights (=%s) must be integers" % q) if q[i] <= 0: raise ValueError( "the weights (=%s) must be positive integers" % q) if not gcd(q) == 1: raise ValueError("the weights (=%s) must be relatively prime" % q) # set default values for base_ring and names base_ring = QQ names = 'z+' for key in kw: if key == 'K': base_ring = kw['K'] elif key == 'base_ring': base_ring = kw['base_ring'] elif key == 'names': names = kw['names'] names = normalize_names(names, m, DEFAULT_PREFIX) else: raise TypeError("got an unexpected keyword argument %r" % key) L = ToricLattice(m) L_sub = L.submodule([L(q)]) Q = L / L_sub rays = [] cones = [] w = list(range(m)) L_basis = L.basis() for i in w: b = L_basis[i] v = Q.coordinate_vector(Q(b)) rays = rays + [v] w_c = w[:i] + w[i + 1:] cones = cones + [tuple(w_c)] fan = Fan(cones, rays) return ToricVariety(fan, coordinate_names=names, base_ring=base_ring)