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)