def _make_ToricVariety(self, name, coordinate_names):
"""
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.
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 = '_cached_'+name
else:
coordinate_names = normalize_names(coordinate_names, len(rays),
DEFAULT_PREFIX)
dict_key = '_cached_'+name+'_'+'_'.join(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)
return self.__dict__[dict_key]
def Cube_deformation(self,k, names=None):
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 [FS]_.
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.
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().ray_matrix()
[ 1 1 -1 -1 -1 -1 1 1]
[ 1 -1 1 -1 -1 1 -1 1]
[ 5 1 1 1 -1 -1 -1 -1]
sage: X_2.gens()
(z0, z1, z2, z3, z4, z5, z6, z7)
REFERENCES:
.. [FS]
William Fulton, Bernd Sturmfels, "Intersection Theory on
Toric Varieties", http://arxiv.org/abs/alg-geom/9403002
"""
# 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 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 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:
- ``K`` -- 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 `K`. ``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 K and names
K = QQ
names = 'z+'
for key in kw:
if key == 'K':
K = kw['K']
if K not in _Fields:
raise TypeError("K (=%r) must be a field" % K)
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 = 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_field=K)