Coverage for local/lib/python2.7/site-packages/sage/geometry/fan.py : 84%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
r""" Rational polyhedral fans
This module was designed as a part of the framework for toric varieties (:mod:`~sage.schemes.toric.variety`, :mod:`~sage.schemes.toric.fano_variety`). While the emphasis is on complete full-dimensional fans, arbitrary fans are supported. Work with distinct lattices. The default lattice is :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>` `N` of the appropriate dimension. The only case when you must specify lattice explicitly is creation of a 0-dimensional fan, where dimension of the ambient space cannot be guessed.
A **rational polyhedral fan** is a *finite* collection of *strictly* convex rational polyhedral cones, such that the intersection of any two cones of the fan is a face of each of them and each face of each cone is also a cone of the fan.
AUTHORS:
- Andrey Novoseltsev (2010-05-15): initial version.
- Andrey Novoseltsev (2010-06-17): substantial improvement during review by Volker Braun.
EXAMPLES:
Use :func:`Fan` to construct fans "explicitly"::
sage: fan = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1,0)]) sage: fan Rational polyhedral fan in 2-d lattice N
In addition to giving such lists of cones and rays you can also create cones first using :func:`~sage.geometry.cone.Cone` and then combine them into a fan. See the documentation of :func:`Fan` for details.
In 2 dimensions there is a unique maximal fan determined by rays, and you can use :func:`Fan2d` to construct it::
sage: fan2d = Fan2d(rays=[(1,0), (0,1), (-1,0)]) sage: fan2d.is_equivalent(fan) True
But keep in mind that in higher dimensions the cone data is essential and cannot be omitted. Instead of building a fan from scratch, for this tutorial we will use an easy way to get two fans associated to :class:`lattice polytopes <sage.geometry.lattice_polytope.LatticePolytopeClass>`: :func:`FaceFan` and :func:`NormalFan`::
sage: fan1 = FaceFan(lattice_polytope.cross_polytope(3)) sage: fan2 = NormalFan(lattice_polytope.cross_polytope(3))
Given such "automatic" fans, you may wonder what are their rays and cones::
sage: fan1.rays() M( 1, 0, 0), M( 0, 1, 0), M( 0, 0, 1), M(-1, 0, 0), M( 0, -1, 0), M( 0, 0, -1) in 3-d lattice M sage: fan1.generating_cones() (3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M)
The last output is not very illuminating. Let's try to improve it::
sage: for cone in fan1: print(cone.rays()) M( 0, 1, 0), M( 0, 0, 1), M(-1, 0, 0) in 3-d lattice M M( 0, 0, 1), M(-1, 0, 0), M( 0, -1, 0) in 3-d lattice M M(-1, 0, 0), M( 0, -1, 0), M( 0, 0, -1) in 3-d lattice M M( 0, 1, 0), M(-1, 0, 0), M( 0, 0, -1) in 3-d lattice M M(1, 0, 0), M(0, 1, 0), M(0, 0, -1) in 3-d lattice M M(1, 0, 0), M(0, 1, 0), M(0, 0, 1) in 3-d lattice M M(1, 0, 0), M(0, 0, 1), M(0, -1, 0) in 3-d lattice M M(1, 0, 0), M(0, -1, 0), M(0, 0, -1) in 3-d lattice M
You can also do ::
sage: for cone in fan1: print(cone.ambient_ray_indices()) (1, 2, 3) (2, 3, 4) (3, 4, 5) (1, 3, 5) (0, 1, 5) (0, 1, 2) (0, 2, 4) (0, 4, 5)
to see indices of rays of the fan corresponding to each cone.
While the above cycles were over "cones in fan", it is obvious that we did not get ALL the cones: every face of every cone in a fan must also be in the fan, but all of the above cones were of dimension three. The reason for this behaviour is that in many cases it is enough to work with generating cones of the fan, i.e. cones which are not faces of bigger cones. When you do need to work with lower dimensional cones, you can easily get access to them using :meth:`~sage.geometry.fan.RationalPolyhedralFan.cones`::
sage: [cone.ambient_ray_indices() for cone in fan1.cones(2)] [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (0, 4), (2, 4), (3, 4), (1, 5), (3, 5), (4, 5), (0, 5)]
In fact, you don't have to type ``.cones``::
sage: [cone.ambient_ray_indices() for cone in fan1(2)] [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (0, 4), (2, 4), (3, 4), (1, 5), (3, 5), (4, 5), (0, 5)]
You may also need to know the inclusion relations between all of the cones of the fan. In this case check out :meth:`~sage.geometry.fan.RationalPolyhedralFan.cone_lattice`::
sage: L = fan1.cone_lattice() sage: L Finite poset containing 28 elements with distinguished linear extension sage: L.bottom() 0-d cone of Rational polyhedral fan in 3-d lattice M sage: L.top() Rational polyhedral fan in 3-d lattice M sage: cone = L.level_sets()[2][0] sage: cone 2-d cone of Rational polyhedral fan in 3-d lattice M sage: sorted(L.hasse_diagram().neighbors(cone)) [1-d cone of Rational polyhedral fan in 3-d lattice M, 1-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M, 3-d cone of Rational polyhedral fan in 3-d lattice M]
You can check how "good" a fan is::
sage: fan1.is_complete() True sage: fan1.is_simplicial() True sage: fan1.is_smooth() True
The face fan of the octahedron is really good! Time to remember that we have also constructed its normal fan::
sage: fan2.is_complete() True sage: fan2.is_simplicial() False sage: fan2.is_smooth() False
This one does have some "problems," but we can fix them::
sage: fan3 = fan2.make_simplicial() sage: fan3.is_simplicial() True sage: fan3.is_smooth() False
Note that we had to save the result of :meth:`~sage.geometry.fan.RationalPolyhedralFan.make_simplicial` in a new fan. Fans in Sage are immutable, so any operation that does change them constructs a new fan.
We can also make ``fan3`` smooth, but it will take a bit more work::
sage: cube = lattice_polytope.cross_polytope(3).polar() sage: sk = cube.skeleton_points(2) sage: rays = [cube.point(p) for p in sk] sage: fan4 = fan3.subdivide(new_rays=rays) sage: fan4.is_smooth() True
Let's see how "different" are ``fan2`` and ``fan4``::
sage: fan2.ngenerating_cones() 6 sage: fan2.nrays() 8 sage: fan4.ngenerating_cones() 48 sage: fan4.nrays() 26
Smoothness does not come for free!
Please take a look at the rest of the available functions below and their complete descriptions. If you need any features that are missing, feel free to suggest them. (Or implement them on your own and submit a patch to Sage for inclusion!) """
#***************************************************************************** # Copyright (C) 2010 Andrey Novoseltsev <novoselt@gmail.com> # Copyright (C) 2010 William Stein <wstein@gmail.com> # # Distributed under the terms of the GNU General Public License (GPL) # # http://www.gnu.org/licenses/ #***************************************************************************** from __future__ import print_function
import collections import warnings import copy
from sage.structure.richcmp import richcmp_method, richcmp from sage.combinat.combination import Combinations from sage.combinat.posets.posets import FinitePoset from sage.geometry.cone import (_ambient_space_point, Cone, ConvexRationalPolyhedralCone, IntegralRayCollection, is_Cone, normalize_rays) from sage.geometry.hasse_diagram import Hasse_diagram_from_incidences from sage.geometry.point_collection import PointCollection from sage.geometry.toric_lattice import ToricLattice, is_ToricLattice from sage.geometry.toric_plotter import ToricPlotter from sage.graphs.digraph import DiGraph from sage.matrix.all import matrix from sage.misc.all import cached_method, walltime, prod from sage.modules.all import vector from sage.rings.all import QQ, ZZ
def is_Fan(x): r""" Check if ``x`` is a Fan.
INPUT:
- ``x`` -- anything.
OUTPUT:
- ``True`` if ``x`` is a fan and ``False`` otherwise.
EXAMPLES::
sage: from sage.geometry.fan import is_Fan sage: is_Fan(1) False sage: fan = toric_varieties.P2().fan() sage: fan Rational polyhedral fan in 2-d lattice N sage: is_Fan(fan) True """
def Fan(cones, rays=None, lattice=None, check=True, normalize=True, is_complete=None, virtual_rays=None, discard_faces=False): r""" Construct a rational polyhedral fan.
.. NOTE::
Approximate time to construct a fan consisting of `n` cones is `n^2/5` seconds. That is half an hour for 100 cones. This time can be significantly reduced in the future, but it is still likely to be `\sim n^2` (with, say, `/500` instead of `/5`). If you know that your input does form a valid fan, use ``check=False`` option to skip consistency checks.
INPUT:
- ``cones`` -- list of either :class:`Cone<sage.geometry.cone.ConvexRationalPolyhedralCone>` objects or lists of integers interpreted as indices of generating rays in ``rays``. These must be only **maximal** cones of the fan, unless ``discard_faces=True`` option is specified;
- ``rays`` -- list of rays given as list or vectors convertible to the rational extension of ``lattice``. If ``cones`` are given by :class:`Cone<sage.geometry.cone.ConvexRationalPolyhedralCone>` objects ``rays`` may be determined automatically. You still may give them explicitly to ensure a particular order of rays in the fan. In this case you must list all rays that appear in ``cones``. You can give "extra" ones if it is convenient (e.g. if you have a big list of rays for several fans), but all "extra" rays will be discarded;
- ``lattice`` -- :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>`, `\ZZ^n`, or any other object that behaves like these. If not specified, an attempt will be made to determine an appropriate toric lattice automatically;
- ``check`` -- by default the input data will be checked for correctness (e.g. that intersection of any two given cones is a face of each). If you know for sure that the input is correct, you may significantly decrease construction time using ``check=False`` option;
- ``normalize`` -- you can further speed up construction using ``normalize=False`` option. In this case ``cones`` must be a list of **sorted** :class:`tuples` and ``rays`` must be immutable primitive vectors in ``lattice``. In general, you should not use this option, it is designed for code optimization and does not give as drastic improvement in speed as the previous one;
- ``is_complete`` -- every fan can determine on its own if it is complete or not, however it can take quite a bit of time for "big" fans with many generating cones. On the other hand, in some situations it is known in advance that a certain fan is complete. In this case you can pass ``is_complete=True`` option to speed up some computations. You may also pass ``is_complete=False`` option, although it is less likely to be beneficial. Of course, passing a wrong value can compromise the integrity of data structures of the fan and lead to wrong results, so you should be very careful if you decide to use this option;
- ``virtual_rays`` -- (optional, computed automatically if needed) a list of ray generators to be used for :meth:`virtual_rays`;
- ``discard_faces`` -- by default, the fan constructor expects the list of **maximal** cones. If you provide "extra" ones and leave ``check=True`` (default), an exception will be raised. If you provide "extra" cones and set ``check=False``, you may get wrong results as assumptions on internal data structures will be invalid. If you want the fan constructor to select the maximal cones from the given input, you may provide ``discard_faces=True`` option (it works both for ``check=True`` and ``check=False``).
OUTPUT:
- a :class:`fan <RationalPolyhedralFan>`.
.. SEEALSO::
In 2 dimensions you can cyclically order the rays. Hence the rays determine a unique maximal fan without having to specify the cones, and you can use :func:`Fan2d` to construct this fan from just the rays.
EXAMPLES:
Let's construct a fan corresponding to the projective plane in several ways::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(0,1), (-1,-1)]) sage: cone3 = Cone([(-1,-1), (1,0)]) sage: P2 = Fan([cone1, cone2, cone2]) Traceback (most recent call last): ... ValueError: you have provided 3 cones, but only 2 of them are maximal! Use discard_faces=True if you indeed need to construct a fan from these cones.
Oops! There was a typo and ``cone2`` was listed twice as a generating cone of the fan. If it was intentional (e.g. the list of cones was generated automatically and it is possible that it contains repetitions or faces of other cones), use ``discard_faces=True`` option::
sage: P2 = Fan([cone1, cone2, cone2], discard_faces=True) sage: P2.ngenerating_cones() 2
However, in this case it was definitely a typo, since the fan of `\mathbb{P}^2` has 3 maximal cones::
sage: P2 = Fan([cone1, cone2, cone3]) sage: P2.ngenerating_cones() 3
Looks better. An alternative way is ::
sage: rays = [(1,0), (0,1), (-1,-1)] sage: cones = [(0,1), (1,2), (2,0)] sage: P2a = Fan(cones, rays) sage: P2a.ngenerating_cones() 3 sage: P2 == P2a False
That may seem wrong, but it is not::
sage: P2.is_equivalent(P2a) True
See :meth:`~RationalPolyhedralFan.is_equivalent` for details.
Yet another way to construct this fan is ::
sage: P2b = Fan(cones, rays, check=False) sage: P2b.ngenerating_cones() 3 sage: P2a == P2b True
If you try the above examples, you are likely to notice the difference in speed, so when you are sure that everything is correct, it is a good idea to use ``check=False`` option. On the other hand, it is usually **NOT** a good idea to use ``normalize=False`` option::
sage: P2c = Fan(cones, rays, check=False, normalize=False) Traceback (most recent call last): ... AttributeError: 'tuple' object has no attribute 'parent'
Yet another way is to use functions :func:`FaceFan` and :func:`NormalFan` to construct fans from :class:`lattice polytopes <sage.geometry.lattice_polytope.LatticePolytopeClass>`.
We have not yet used ``lattice`` argument, since if was determined automatically::
sage: P2.lattice() 2-d lattice N sage: P2b.lattice() 2-d lattice N
However, it is necessary to specify it explicitly if you want to construct a fan without rays or cones::
sage: Fan([], []) Traceback (most recent call last): ... ValueError: you must specify the lattice when you construct a fan without rays and cones! sage: F = Fan([], [], lattice=ToricLattice(2, "L")) sage: F Rational polyhedral fan in 2-d lattice L sage: F.lattice_dim() 2 sage: F.dim() 0 """ # "global" does not work here... if normalize: V = normalize_rays(V, lattice) if check: R = PointCollection(V, lattice) V = PointCollection(V, lattice) d = lattice.dimension() if len(V) != d - R.dim() or (R + V).dim() != d: raise ValueError("virtual rays must be linearly " "independent and with other rays span the ambient space.")
except TypeError: raise TypeError( "cones must be given as an iterable!" "\nGot: %s" % cones) lattice = normalize_rays(rays, lattice)[0].parent() else: "construct a fan without rays and cones!") # Construct the fan from Cone objects # If we determine the lattice automatically, we don't want to force # any conversion. TODO: take into account coercions? raise ValueError("cones belong to different lattices " "(%s and %s), cannot determine the lattice of the " "fan!" % (lattice, cone.lattice())) cones[i] = Cone(cone.rays(), lattice, check=False) raise ValueError( "cones of a fan must be strictly convex!") # Optimization for fans generated by a single cone raise ValueError( "if rays are given, they must include all rays of the fan!") else: # Maybe we should compute all faces of all cones and save them for # later if we are doing this check? reverse=True): else: raise ValueError( "these cones cannot belong to the same fan!" "\nCone 1 rays: %s\nCone 2 rays: %s" % (g_cone.rays(), cone.rays())) else: "of them are maximal! Use discard_faces=True if you " "indeed need to construct a fan from these cones." % (len(cones), len(generating_cones))) for cone in cones) # Construct the fan from rays and "tuple cones" except TypeError: raise TypeError("cannot interpret %s as a cone!" % cone) # If we do need to make all the check, build explicit cone objects first rays, lattice, is_complete=is_complete, virtual_rays=virtual_rays, discard_faces=discard_faces)
def FaceFan(polytope, lattice=None): r""" Construct the face fan of the given rational ``polytope``.
INPUT:
- ``polytope`` -- a :func:`polytope <sage.geometry.polyhedron.constructor.Polyhedron>` over `\QQ` or a :class:`lattice polytope <sage.geometry.lattice_polytope.LatticePolytopeClass>`. A (not necessarily full-dimensional) polytope containing the origin in its :meth:`relative interior <sage.geometry.polyhedron.base.Polyhedron_base.relative_interior_contains>`.
- ``lattice`` -- :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>`, `\ZZ^n`, or any other object that behaves like these. If not specified, an attempt will be made to determine an appropriate toric lattice automatically.
OUTPUT:
- :class:`rational polyhedral fan <RationalPolyhedralFan>`.
See also :func:`NormalFan`.
EXAMPLES:
Let's construct the fan corresponding to the product of two projective lines::
sage: diamond = lattice_polytope.cross_polytope(2) sage: P1xP1 = FaceFan(diamond) sage: P1xP1.rays() M( 1, 0), M( 0, 1), M(-1, 0), M( 0, -1) in 2-d lattice M sage: for cone in P1xP1: print(cone.rays()) M(-1, 0), M( 0, -1) in 2-d lattice M M( 0, 1), M(-1, 0) in 2-d lattice M M(1, 0), M(0, 1) in 2-d lattice M M(1, 0), M(0, -1) in 2-d lattice M
TESTS::
sage: cuboctahed = polytopes.cuboctahedron() sage: FaceFan(cuboctahed) Rational polyhedral fan in 3-d lattice M sage: cuboctahed.is_lattice_polytope(), cuboctahed.dilation(1/2).is_lattice_polytope() (True, False) sage: fan1 = FaceFan(cuboctahed) sage: fan2 = FaceFan(cuboctahed.dilation(2).lattice_polytope()) sage: fan1.is_equivalent(fan2) True
sage: ray = Polyhedron(vertices=[(-1,-1)], rays=[(1,1)]) sage: FaceFan(ray) Traceback (most recent call last): ... ValueError: face fans are defined only for polytopes containing the origin as an interior point!
sage: interval_in_QQ2 = Polyhedron([ (0,-1), (0,+1) ]) sage: FaceFan(interval_in_QQ2).generating_cones() (1-d cone of Rational polyhedral fan in 2-d lattice M, 1-d cone of Rational polyhedral fan in 2-d lattice M)
sage: FaceFan(Polyhedron([(-1,0), (1,0), (0,1)])) # origin on facet Traceback (most recent call last): ... ValueError: face fans are defined only for polytopes containing the origin as an interior point! """ "face fans are defined only for polytopes containing " "the origin as an interior point!") raise interior_point_error else: polytope.relative_interior_contains(origin)): for facet in polytope.inequalities() ] # Since default lattice polytopes are in the M lattice, # treat polyhedra as being there as well. is_complete=is_complete)
def NormalFan(polytope, lattice=None): r""" Construct the normal fan of the given rational ``polytope``.
INPUT:
- ``polytope`` -- a full-dimensional :func:`polytope <sage.geometry.polyhedron.constructor.Polyhedron>` over `\QQ` or:class:`lattice polytope <sage.geometry.lattice_polytope.LatticePolytopeClass>`.
- ``lattice`` -- :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>`, `\ZZ^n`, or any other object that behaves like these. If not specified, an attempt will be made to determine an appropriate toric lattice automatically.
OUTPUT:
- :class:`rational polyhedral fan <RationalPolyhedralFan>`.
See also :func:`FaceFan`.
EXAMPLES:
Let's construct the fan corresponding to the product of two projective lines::
sage: square = LatticePolytope([(1,1), (-1,1), (-1,-1), (1,-1)]) sage: P1xP1 = NormalFan(square) sage: P1xP1.rays() N( 1, 0), N( 0, 1), N(-1, 0), N( 0, -1) in 2-d lattice N sage: for cone in P1xP1: print(cone.rays()) N(-1, 0), N( 0, -1) in 2-d lattice N N(1, 0), N(0, -1) in 2-d lattice N N(1, 0), N(0, 1) in 2-d lattice N N( 0, 1), N(-1, 0) in 2-d lattice N
sage: cuboctahed = polytopes.cuboctahedron() sage: NormalFan(cuboctahed) Rational polyhedral fan in 3-d lattice N
TESTS::
sage: cuboctahed.is_lattice_polytope(), cuboctahed.dilation(1/2).is_lattice_polytope() (True, False) sage: fan1 = NormalFan(cuboctahed) sage: fan2 = NormalFan(cuboctahed.dilation(2).lattice_polytope()) sage: fan1.is_equivalent(fan2) True """ 'the normal fan is only defined for full-dimensional polytopes') raise dimension_error else: for vertex in polytope.vertices() ]
def Fan2d(rays, lattice=None): """ Construct the maximal 2-d fan with given ``rays``.
In two dimensions we can uniquely construct a fan from just rays, just by cyclically ordering the rays and constructing as many cones as possible. This is why we implement a special constructor for this case.
INPUT:
- ``rays`` -- list of rays given as list or vectors convertible to the rational extension of ``lattice``. Duplicate rays are removed without changing the ordering of the remaining rays.
- ``lattice`` -- :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>`, `\ZZ^n`, or any other object that behaves like these. If not specified, an attempt will be made to determine an appropriate toric lattice automatically.
EXAMPLES::
sage: Fan2d([(0,1), (1,0)]) Rational polyhedral fan in 2-d lattice N sage: Fan2d([], lattice=ToricLattice(2, 'myN')) Rational polyhedral fan in 2-d lattice myN
The ray order is as specified, even if it is not the cyclic order::
sage: fan1 = Fan2d([(0,1), (1,0)]) sage: fan1.rays() N(0, 1), N(1, 0) in 2-d lattice N
sage: fan2 = Fan2d([(1,0), (0,1)]) sage: fan2.rays() N(1, 0), N(0, 1) in 2-d lattice N
sage: fan1 == fan2, fan1.is_equivalent(fan2) (False, True)
sage: fan = Fan2d([(1,1), (-1,-1), (1,-1), (-1,1)]) sage: [ cone.ambient_ray_indices() for cone in fan ] [(2, 1), (1, 3), (3, 0), (0, 2)] sage: fan.is_complete() True
TESTS::
sage: Fan2d([(0,1), (0,1)]).generating_cones() (1-d cone of Rational polyhedral fan in 2-d lattice N,)
sage: Fan2d([(1,1), (-1,-1)]).generating_cones() (1-d cone of Rational polyhedral fan in 2-d lattice N, 1-d cone of Rational polyhedral fan in 2-d lattice N)
sage: Fan2d([]) Traceback (most recent call last): ... ValueError: you must specify a 2-dimensional lattice when you construct a fan without rays.
sage: Fan2d([(3,4)]).rays() N(3, 4) in 2-d lattice N
sage: Fan2d([(0,1,0)]) Traceback (most recent call last): ... ValueError: the lattice must be 2-dimensional.
sage: Fan2d([(0,1), (1,0), (0,0)]) Traceback (most recent call last): ... ValueError: only non-zero vectors define rays
sage: Fan2d([(0, -2), (2, -10), (1, -3), (2, -9), (2, -12), (1, 1), ....: (2, 1), (1, -5), (0, -6), (1, -7), (0, 1), (2, -4), ....: (2, -2), (1, -9), (1, -8), (2, -6), (0, -1), (0, -3), ....: (2, -11), (2, -8), (1, 0), (0, -5), (1, -4), (2, 0), ....: (1, -6), (2, -7), (2, -5), (-1, -3), (1, -1), (1, -2), ....: (0, -4), (2, -3), (2, -1)]).cone_lattice() Finite poset containing 44 elements with distinguished linear extension
sage: Fan2d([(1,1)]).is_complete() False sage: Fan2d([(1,1), (-1,-1)]).is_complete() False sage: Fan2d([(1,0), (0,1)]).is_complete() False """ 'you construct a fan without rays.')
# remove multiple rays without changing order else: # all given rays were the same
# each sorted_rays entry = (angle, ray, original_ray_index) else:
class Cone_of_fan(ConvexRationalPolyhedralCone): r""" Construct a cone belonging to a fan.
.. WARNING::
This class does not check that the input defines a valid cone of a fan. You must not construct objects of this class directly.
In addition to all of the properties of "regular" :class:`cones <sage.geometry.cone.ConvexRationalPolyhedralCone>`, such cones know their relation to the fan.
INPUT:
- ``ambient`` -- fan whose cone is constructed;
- ``ambient_ray_indices`` -- increasing list or tuple of integers, indices of rays of ``ambient`` generating this cone.
OUTPUT:
- cone of ``ambient``.
EXAMPLES:
The intended way to get objects of this class is the following::
sage: fan = toric_varieties.P1xP1().fan() sage: cone = fan.generating_cone(0) sage: cone 2-d cone of Rational polyhedral fan in 2-d lattice N sage: cone.ambient_ray_indices() (0, 2) sage: cone.star_generator_indices() (0,) """
def __init__(self, ambient, ambient_ray_indices): r""" See :class:`Cone_of_Fan` for documentation.
TESTS:
The following code is likely to construct an invalid object, we just test that creation of cones of fans is working::
sage: fan = toric_varieties.P1xP1().fan() sage: cone = sage.geometry.fan.Cone_of_fan(fan, (0,)) sage: cone 1-d cone of Rational polyhedral fan in 2-d lattice N sage: TestSuite(cone).run() """ ambient=ambient, ambient_ray_indices=ambient_ray_indices) # Because if not, this cone should not have been constructed
def _repr_(self): r""" Return a string representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: P1xP1 = toric_varieties.P1xP1() sage: cone = P1xP1.fan().generating_cone(0) sage: cone._repr_() '2-d cone of Rational polyhedral fan in 2-d lattice N' sage: cone.facets()[0]._repr_() '1-d cone of Rational polyhedral fan in 2-d lattice N' """ # The base class would print "face of" instead of "cone of"
def star_generator_indices(self): r""" Return indices of generating cones of the "ambient fan" containing ``self``.
OUTPUT:
- increasing :class:`tuple` of integers.
EXAMPLES::
sage: P1xP1 = toric_varieties.P1xP1() sage: cone = P1xP1.fan().generating_cone(0) sage: cone.star_generator_indices() (0,)
TESTS:
A mistake in this function used to cause the problem reported in :trac:`9782`. We check that now everything is working smoothly::
sage: f = Fan([(0, 2, 4), ....: (0, 4, 5), ....: (0, 3, 5), ....: (0, 1, 3), ....: (0, 1, 2), ....: (2, 4, 6), ....: (4, 5, 6), ....: (3, 5, 6), ....: (1, 3, 6), ....: (1, 2, 6)], ....: [(-1, 0, 0), ....: (0, -1, 0), ....: (0, 0, -1), ....: (0, 0, 1), ....: (0, 1, 2), ....: (0, 1, 3), ....: (1, 0, 4)]) sage: f.is_complete() True sage: X = ToricVariety(f) sage: X.fan().is_complete() True """
def star_generators(self): r""" Return indices of generating cones of the "ambient fan" containing ``self``.
OUTPUT:
- increasing :class:`tuple` of integers.
EXAMPLES::
sage: P1xP1 = toric_varieties.P1xP1() sage: cone = P1xP1.fan().generating_cone(0) sage: cone.star_generators() (2-d cone of Rational polyhedral fan in 2-d lattice N,) """ for i in self.star_generator_indices())
@richcmp_method class RationalPolyhedralFan(IntegralRayCollection, collections.Callable, collections.Container): r""" Create a rational polyhedral fan.
.. WARNING::
This class does not perform any checks of correctness of input nor does it convert input into the standard representation. Use :func:`Fan` to construct fans from "raw data" or :func:`FaceFan` and :func:`NormalFan` to get fans associated to polytopes.
Fans are immutable, but they cache most of the returned values.
INPUT:
- ``cones`` -- list of generating cones of the fan, each cone given as a list of indices of its generating rays in ``rays``;
- ``rays`` -- list of immutable primitive vectors in ``lattice`` consisting of exactly the rays of the fan (i.e. no "extra" ones);
- ``lattice`` -- :class:`ToricLattice <sage.geometry.toric_lattice.ToricLatticeFactory>`, `\ZZ^n`, or any other object that behaves like these. If ``None``, it will be determined as :func:`parent` of the first ray. Of course, this cannot be done if there are no rays, so in this case you must give an appropriate ``lattice`` directly;
- ``is_complete`` -- if given, must be ``True`` or ``False`` depending on whether this fan is complete or not. By default, it will be determined automatically if necessary;
- ``virtual_rays`` -- if given, must the a list of immutable primitive vectors in ``lattice``, see :meth:`virtual_rays` for details. By default, it will be determined automatically if necessary.
OUTPUT:
- rational polyhedral fan. """
def __init__(self, cones, rays, lattice, is_complete=None, virtual_rays=None): r""" See :class:`RationalPolyhedralFan` for documentation.
TESTS::
sage: v = vector([0,1]) sage: v.set_immutable() sage: f = sage.geometry.fan.RationalPolyhedralFan( ....: [(0,)], [v], None) sage: f.rays() (0, 1) in Ambient free module of rank 2 over the principal ideal domain Integer Ring sage: TestSuite(f).run() sage: f = Fan([(0,)], [(0,1)]) sage: TestSuite(f).run() """ # Knowing completeness drastically affects the speed of cone lattice # computation and containment check, so we have a special way to # optimize it. # Computing virtual rays is fast, but it may be convenient to choose # them based on relation to other cones and fans. self._virtual_rays = PointCollection(virtual_rays, self.lattice())
def _sage_input_(self, sib, coerced): """ Return Sage command to reconstruct ``self``.
See :mod:`sage.misc.sage_input` for details.
EXAMPLES::
sage: fan = Fan([Cone([(1,0), (1,1)]), Cone([(-1,-1)])]) sage: sage_input(fan) Fan(cones=[[0, 1], [2]], rays=[(1, 0), (1, 1), (-1, -1)]) """
def __call__(self, dim=None, codim=None): r""" Return the specified cones of ``self``.
.. NOTE::
"Direct call" syntax is a synonym for :meth:`cones` method except that in the case of no input parameters this function returns just ``self``.
INPUT:
- ``dim`` -- dimension of the requested cones;
- ``codim`` -- codimension of the requested cones.
OUTPUT:
- cones of ``self`` of the specified (co)dimension if it was given, otherwise ``self``.
TESTS::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan(1) (1-d cone of Rational polyhedral fan in 2-d lattice N, 1-d cone of Rational polyhedral fan in 2-d lattice N, 1-d cone of Rational polyhedral fan in 2-d lattice N) sage: fan(2) (2-d cone of Rational polyhedral fan in 2-d lattice N,) sage: fan(dim=2) (2-d cone of Rational polyhedral fan in 2-d lattice N,) sage: fan(codim=2) (0-d cone of Rational polyhedral fan in 2-d lattice N,) sage: fan(dim=1, codim=1) Traceback (most recent call last): ... ValueError: dimension and codimension cannot be specified together! sage: fan() is fan True """ # "self.cones()" returns all cones, but for the call syntax # "self()" we return just "self", which seems to be more natural # and convenient for ToricVariety.fan() method. else:
def __richcmp__(self, right, op): r""" Compare ``self`` and ``right``.
INPUT:
- ``right`` -- anything.
OUTPUT:
boolean
There is equality if ``right`` is also a fan, their rays are the same and stored in the same order, and their generating cones are the same and stored in the same order.
TESTS::
sage: f1 = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: f2 = Fan(cones=[(1,2), (0,1)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: f3 = Fan(cones=[(1,2), (0,1)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: f1 > f2 True sage: f2 < f1 True sage: f2 == f3 True sage: f2 is f3 False """ self.generating_cones()], [right.rays(), right.virtual_rays(), right.generating_cones()], op) else:
def __contains__(self, cone): r""" Check if ``cone`` is equivalent to a cone of the fan.
See :meth:`_contains` (which is called by this function) for documentation.
TESTS::
sage: cone1 = Cone([(0,-1), (1,0)]) sage: cone2 = Cone([(1,0), (0,1)]) sage: f = Fan([cone1, cone2]) sage: f.generating_cone(0) in f True sage: cone1 in f True sage: (1,1) in f # not a cone False sage: "Ceci n'est pas un cone" in f False """
def __iter__(self): r""" Return an iterator over generating cones of ``self``.
OUTPUT:
- iterator.
TESTS::
sage: f = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: for cone in f: print(cone.rays()) N(1, 0), N(0, 1) in 2-d lattice N N( 0, 1), N(-1, 0) in 2-d lattice N """
def _compute_cone_lattice(self): r""" Compute the cone lattice of ``self``.
See :meth:`cone_lattice` for documentation.
TESTS:
We use different algorithms depending on available information. One of the common cases is a fan which is KNOWN to be complete, i.e. we do not even need to check if it is complete.
sage: fan = toric_varieties.P1xP1().fan() sage: fan.cone_lattice() # indirect doctest Finite poset containing 10 elements with distinguished linear extension
These 10 elements are: 1 origin, 4 rays, 4 generating cones, 1 fan.
Another common case is the fan of faces of a single cone::
sage: quadrant = Cone([(1,0), (0,1)]) sage: fan = Fan([quadrant]) sage: fan.cone_lattice() # indirect doctest Finite poset containing 5 elements with distinguished linear extension
These 5 elements are: 1 origin, 2 rays, 1 generating cone, 1 fan.
A subcase of this common case is treatment of fans consisting of the origin only, which used to be handled incorrectly :trac:`18613`::
sage: fan = Fan([Cone([], ToricLattice(0))]) sage: list(fan.cone_lattice()) [0-d cone of Rational polyhedral fan in 0-d lattice N, Rational polyhedral fan in 0-d lattice N] sage: fan = Fan([Cone([], ToricLattice(1))]) sage: list(fan.cone_lattice()) [0-d cone of Rational polyhedral fan in 1-d lattice N, Rational polyhedral fan in 1-d lattice N]
Finally, we have "intermediate" fans which are incomplete but are generated by more than one cone::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.rays() N( 0, 1), N( 1, 0), N(-1, 0) in 2-d lattice N sage: for cone in fan: print(cone.ambient_ray_indices()) (0, 1) (2,) sage: L = fan.cone_lattice() # indirect doctest sage: L Finite poset containing 6 elements with distinguished linear extension
Here we got 1 origin, 3 rays (one is a generating cone), 1 2-dimensional cone (a generating one), and 1 fan. """ # Define a face constructor # Check directly if we know completeness already, since *determining* # completeness relies on this function # We can use a fast way for complete fans # When there are no rays, fan is the only atom self._ray_to_cones() if self.rays() else [()], (cone.ambient_ray_indices() for cone in self), FanFace, key = id(self)) else: # For general fans we will "merge" face lattices of generating # cones. # face index |---> (indices of containing generating cones) # During construction index 0 will correspond to the fan # We think of the fan not being in the cone even when there is # only one cone # Set up translation of faces of cone to rays and indices # We make a standalone cone to compute its standalone face # lattice, since cones of fans get their lattices from fans check=False, normalize=False).face_lattice() for ray in f.ambient_ray_indices()) # Add all relations between faces of cone to L rays_to_index[face_to_rays[g]]) # Add the inclusion of cone into the fan itself rays_to_index[face_to_rays[L_cone.top()]], 0)
# Enumeration of graph vertices must be a linear extension of the # poset # Make sure that generating cones are in the end in proper order # Make sure that rays are in the beginning in proper order # "Invert" this list to a dictionary
rays, tuple(index_to_cones[index])) # We need "special treatment" for the whole fan. If we added its # ray incidence information to the total list, it would be # confused with the generating cone in the case of a single cone.
def _contains(self, cone): r""" Check if ``cone`` is equivalent to a cone of the fan.
This function is called by :meth:`__contains__` and :meth:`contains` to ensure the same call depth for warning messages.
INPUT:
- ``cone`` -- anything.
OUTPUT:
- ``False`` if ``cone`` is not a cone or if ``cone`` is not equivalent to a cone of the fan. ``True`` otherwise.
TESTS::
sage: cone1 = Cone([(0,-1), (1,0)]) sage: cone2 = Cone([(1,0), (0,1)]) sage: f = Fan([cone1, cone2]) sage: f._contains(cone1) True sage: f._contains((1,1)) # this is not a cone! False
Note that the ambient fan of the cone does not matter::
sage: cone1_f = f.generating_cone(0) sage: cone1_f is cone1 False sage: cone1_f.is_equivalent(cone1) True sage: cone1 in Fan([cone1, cone2]) # not a cone of any particular fan True sage: cone1_f in Fan([cone1, cone2]) # belongs to different fan, but equivalent cone True """ warnings.warn("you have checked if a fan contains a cone " "from another lattice, this is always False!", stacklevel=3)
def support_contains(self, *args): r""" Check if a point is contained in the support of the fan.
The support of a fan is the union of all cones of the fan. If you want to know whether the fan contains a given cone, you should use :meth:`contains` instead.
INPUT:
- ``*args`` -- an element of ``self.lattice()`` or something that can be converted to it (for example, a list of coordinates).
OUTPUT:
- ``True`` if ``point`` is contained in the support of the fan, ``False`` otherwise.
TESTS::
sage: cone1 = Cone([(0,-1), (1,0)]) sage: cone2 = Cone([(1,0), (0,1)]) sage: f = Fan([cone1, cone2])
We check if some points are in this fan::
sage: f.support_contains(f.lattice()(1,0)) True sage: f.support_contains(cone1) # a cone is not a point of the lattice False sage: f.support_contains((1,0)) True sage: f.support_contains(1,1) True sage: f.support_contains((-1,0)) False sage: f.support_contains(f.lattice().dual()(1,0)) #random output (warning) False sage: f.support_contains(f.lattice().dual()(1,0)) False sage: f.support_contains(1) False sage: f.support_contains(0) # 0 converts to the origin in the lattice True sage: f.support_contains(1/2, sqrt(3)) True sage: f.support_contains(-1/2, sqrt(3)) False """ else:
warnings.warn("you have checked if a fan contains a point " "from an incompatible lattice, this is False!", stacklevel=3) return True
def cartesian_product(self, other, lattice=None): r""" Return the Cartesian product of ``self`` with ``other``.
INPUT:
- ``other`` -- a :class:`rational polyhedral fan <sage.geometry.fan.RationalPolyhedralFan>`;
- ``lattice`` -- (optional) the ambient lattice for the Cartesian product fan. By default, the direct sum of the ambient lattices of ``self`` and ``other`` is constructed.
OUTPUT:
- a :class:`fan <RationalPolyhedralFan>` whose cones are all pairwise Cartesian products of the cones of ``self`` and ``other``.
EXAMPLES::
sage: K = ToricLattice(1, 'K') sage: fan1 = Fan([[0],[1]],[(1,),(-1,)], lattice=K) sage: L = ToricLattice(2, 'L') sage: fan2 = Fan(rays=[(1,0),(0,1),(-1,-1)], ....: cones=[[0,1],[1,2],[2,0]], lattice=L) sage: fan1.cartesian_product(fan2) Rational polyhedral fan in 3-d lattice K+L sage: _.ngenerating_cones() 6 """ other, lattice) for cone in other] self._is_complete and other._is_complete)
def __neg__(self): """ Return the fan where each cone is replaced by the opposite cone.
EXAMPLES::
sage: c0 = Cone([(1,1),(0,1)]) sage: c1 = Cone([(1,1),(1,0)]) sage: F = Fan([c0, c1]); F Rational polyhedral fan in 2-d lattice N sage: G = -F; G # indirect doctest Rational polyhedral fan in 2-d lattice N sage: -G==F True sage: G.rays() N( 0, -1), N(-1, 0), N(-1, -1) in 2-d lattice N """
def common_refinement(self, other): """ Return the common refinement of this fan and ``other``.
INPUT:
- ``other`` -- a :class:`fan <RationalPolyhedralFan>` in the same :meth:`lattice` and with the same support as this fan
OUTPUT:
- a :class:`fan <RationalPolyhedralFan>`
EXAMPLES:
Refining a fan with itself gives itself::
sage: F0 = Fan2d([(1,0),(0,1),(-1,0),(0,-1)]) sage: F0.common_refinement(F0) == F0 True
A more complex example with complete fans::
sage: F1 = Fan([[0],[1]],[(1,),(-1,)]) sage: F2 = Fan2d([(1,0),(1,1),(0,1),(-1,0),(0,-1)]) sage: F3 = F2.cartesian_product(F1) sage: F4 = F1.cartesian_product(F2) sage: FF = F3.common_refinement(F4) sage: F3.ngenerating_cones() 10 sage: F4.ngenerating_cones() 10 sage: FF.ngenerating_cones() 13
An example with two non-complete fans with the same support::
sage: F5 = Fan2d([(1,0),(1,2),(0,1)]) sage: F6 = Fan2d([(1,0),(2,1),(0,1)]) sage: F5.common_refinement(F6).ngenerating_cones() 3
Both fans must live in the same lattice::
sage: F0.common_refinement(F1) Traceback (most recent call last): ... ValueError: the fans are not in the same lattice """ # Construct the opposite morphism to ensure support equality
def _latex_(self): r""" Return a LaTeX representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: f = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: f._latex_() '\\Sigma^{2}' """
def _ray_to_cones(self, i=None): r""" Return the set of generating cones containing the ``i``-th ray.
INPUT:
- ``i`` -- integer, index of a ray of ``self``.
OUTPUT:
- :class:`frozenset` of indices of generating cones of ``self`` containing the ``i``-th ray if ``i`` was given, :class:`tuple` of these sets for all rays otherwise.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan._ray_to_cones(0) frozenset({0, 3}) sage: fan._ray_to_cones() (frozenset({0, 3}), frozenset({1, 2}), frozenset({0, 1}), frozenset({2, 3})) """ # This function is close to self(1)[i].star_generator_indices(), but # it does not require computation of the cone lattice and is # convenient for internal purposes. for rtc in ray_to_cones) else:
def _repr_(self): r""" Return a string representation of ``self``.
OUTPUT:
- string.
TESTS::
sage: f = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: check=False) sage: f._repr_() 'Rational polyhedral fan in 2-d lattice N' sage: f = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1, 0)], ....: lattice=ZZ^2, ....: check=False) sage: f._repr_() 'Rational polyhedral fan in 2-d lattice' """ else:
def _subdivide_stellar(self, new_rays, verbose): r""" Return iterative stellar subdivision of ``self`` via ``new_rays``.
INPUT:
- ``new_rays`` -- immutable primitive vectors in the lattice of ``self``;
- ``verbose`` -- if ``True``, some timing information will be printed.
OUTPUT:
- rational polyhedral fan.
TESTS::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: new_rays = sage.geometry.cone.normalize_rays([(1,1)], None) sage: fan = Fan([cone1, cone2]) sage: fan._subdivide_stellar(new_rays, False) Rational polyhedral fan in 2-d lattice N sage: fan = Fan([cone1]) sage: new_fan = fan._subdivide_stellar(new_rays, True) R:1/1 C:2 T:...(ms) T/new:...(ms) T/all:...(ms) sage: new_fan.rays() N(1, 0), N(0, 1), N(1, 1) in 2-d lattice N sage: for cone in new_fan: print(cone.ambient_ray_indices()) (0, 2) (1, 2)
We make sure that this function constructs cones with ordered ambient ray indices (see :trac:`9812`)::
sage: C = Cone([(1,0,0), (0,1,0), (1,0,1), (0,1,1)]) sage: F = Fan([C]).make_simplicial() sage: [cone.ambient_ray_indices() for cone in F] [(0, 2, 3), (0, 1, 3)] """ for facet in cone.facets() if ray not in facet) else: % (n + 1, len(new_rays), len(new), t * 1000, T_new, t / len(new) * 1000)) if ray not in self.rays().set()) for cone in cones)
def cone_containing(self, *points): r""" Return the smallest cone of ``self`` containing all given points.
INPUT:
- either one or more indices of rays of ``self``, or one or more objects representing points of the ambient space of ``self``, or a list of such objects (you CANNOT give a list of indices).
OUTPUT:
- A :class:`cone of fan <Cone_of_fan>` whose ambient fan is ``self``.
.. NOTE::
We think of the origin as of the smallest cone containing no rays at all. If there is no ray in ``self`` that contains all ``rays``, a ``ValueError`` exception will be raised.
EXAMPLES::
sage: cone1 = Cone([(0,-1), (1,0)]) sage: cone2 = Cone([(1,0), (0,1)]) sage: f = Fan([cone1, cone2]) sage: f.rays() N(0, 1), N(0, -1), N(1, 0) in 2-d lattice N sage: f.cone_containing(0) # ray index 1-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing(0, 1) # ray indices Traceback (most recent call last): ... ValueError: there is no cone in Rational polyhedral fan in 2-d lattice N containing all of the given rays! Ray indices: [0, 1] sage: f.cone_containing(0, 2) # ray indices 2-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing((0,1)) # point 1-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing([(0,1)]) # point 1-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing((1,1)) 2-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing((1,1), (1,0)) 2-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing() 0-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing((0,0)) 0-d cone of Rational polyhedral fan in 2-d lattice N sage: f.cone_containing((-1,1)) Traceback (most recent call last): ... ValueError: there is no cone in Rational polyhedral fan in 2-d lattice N containing all of the given points! Points: [N(-1, 1)]
TESTS::
sage: fan = Fan(cones=[(0,1,2,3), (0,1,4)], ....: rays=[(1,1,1), (1,-1,1), (1,-1,-1), (1,1,-1), (0,0,1)]) sage: fan.cone_containing(0).rays() N(1, 1, 1) in 3-d lattice N """ # Got ray indices "the given rays! Ray indices: %s" % (self, rays)) self.generating_cone(cone)) # This cone may be too big in the case of incomplete fans # Got points (hopefully) else: raise # If we are still here, points are good # First we try to find a generating cone containing all points "the given points! Points: %s" % (self, points)) # Now we take the intersection of facets that contain all points
def cone_lattice(self): r""" Return the cone lattice of ``self``.
This lattice will have the origin as the bottom (we do not include the empty set as a cone) and the fan itself as the top.
OUTPUT:
- :class:`finite poset <sage.combinat.posets.posets.FinitePoset` of :class:`cones of fan<Cone_of_fan>`, behaving like "regular" cones, but also containing the information about their relation to this fan, namely, the contained rays and containing generating cones. The top of the lattice will be this fan itself (*which is not a* :class:`cone of fan<Cone_of_fan>`).
See also :meth:`cones`.
EXAMPLES:
Cone lattices can be computed for arbitrary fans::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.rays() N( 0, 1), N( 1, 0), N(-1, 0) in 2-d lattice N sage: for cone in fan: print(cone.ambient_ray_indices()) (0, 1) (2,) sage: L = fan.cone_lattice() sage: L Finite poset containing 6 elements with distinguished linear extension
These 6 elements are the origin, three rays, one two-dimensional cone, and the fan itself\ . Since we do add the fan itself as the largest face, you should be a little bit careful with this last element::
sage: for face in L: print(face.ambient_ray_indices()) Traceback (most recent call last): ... AttributeError: 'RationalPolyhedralFan' object has no attribute 'ambient_ray_indices' sage: L.top() Rational polyhedral fan in 2-d lattice N
For example, you can do ::
sage: for l in L.level_sets()[:-1]: ....: print([f.ambient_ray_indices() for f in l]) [()] [(0,), (1,), (2,)] [(0, 1)]
If the fan is complete, its cone lattice is atomic and coatomic and can (and will!) be computed in a much more efficient way, but the interface is exactly the same::
sage: fan = toric_varieties.P1xP1().fan() sage: L = fan.cone_lattice() sage: for l in L.level_sets()[:-1]: ....: print([f.ambient_ray_indices() for f in l]) [()] [(0,), (1,), (2,), (3,)] [(0, 2), (1, 2), (0, 3), (1, 3)]
Let's also consider the cone lattice of a fan generated by a single cone::
sage: fan = Fan([cone1]) sage: L = fan.cone_lattice() sage: L Finite poset containing 5 elements with distinguished linear extension
Here these 5 elements correspond to the origin, two rays, one generating cone of dimension two, and the whole fan. While this single cone "is" the whole fan, it is consistent and convenient to distinguish them in the cone lattice. """
# Internally we use this name for a uniform behaviour of cones and fans. _face_lattice_function = cone_lattice
def __getstate__(self): r""" Return the dictionary that should be pickled.
OUTPUT:
- :class:`dict`.
TESTS::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.cone_lattice() Finite poset containing 6 elements with distinguished linear extension sage: fan._test_pickling() """ # TODO: do we want to keep the cone lattice in the pickle? # Currently there is an unpickling loop if do. # See Cone.__getstate__ for a similar problem and discussion.
def cones(self, dim=None, codim=None): r""" Return the specified cones of ``self``.
INPUT:
- ``dim`` -- dimension of the requested cones;
- ``codim`` -- codimension of the requested cones.
.. NOTE::
You can specify at most one input parameter.
OUTPUT:
- :class:`tuple` of cones of ``self`` of the specified (co)dimension, if either ``dim`` or ``codim`` is given. Otherwise :class:`tuple` of such tuples for all existing dimensions.
EXAMPLES::
sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan(dim=0) (0-d cone of Rational polyhedral fan in 2-d lattice N,) sage: fan(codim=2) (0-d cone of Rational polyhedral fan in 2-d lattice N,) sage: for cone in fan.cones(1): cone.ray(0) N(0, 1) N(1, 0) N(-1, 0) sage: fan.cones(2) (2-d cone of Rational polyhedral fan in 2-d lattice N,)
You cannot specify both dimension and codimension, even if they "agree"::
sage: fan(dim=1, codim=1) Traceback (most recent call last): ... ValueError: dimension and codimension cannot be specified together!
But it is OK to ask for cones of too high or low (co)dimension::
sage: fan(-1) () sage: fan(3) () sage: fan(codim=4) () """ # It seems that there is no reason to believe that the order of # faces in level sets has anything to do with the order of # vertices in the Hasse diagram of FinitePoset. So, while # Hasse_diagram_from_incidences tried to ensure a "good order," # we will sort faces corresponding to rays, as well as faces # corresponding to generating cones, if they are all of the same # dimension (otherwise it is not very useful). cone.star_generator_indices()[0]) "dimension and codimension cannot be specified together!")
def contains(self, cone): r""" Check if a given ``cone`` is equivalent to a cone of the fan.
INPUT:
- ``cone`` -- anything.
OUTPUT:
- ``False`` if ``cone`` is not a cone or if ``cone`` is not equivalent to a cone of the fan. ``True`` otherwise.
.. NOTE::
Recall that a fan is a (finite) collection of cones. A cone is contained in a fan if it is equivalent to one of the cones of the fan. In particular, it is possible that all rays of the cone are in the fan, but the cone itself is not.
If you want to know whether a point is in the support of the fan, you should use :meth:`support_contains`.
EXAMPLES:
We first construct a simple fan::
sage: cone1 = Cone([(0,-1), (1,0)]) sage: cone2 = Cone([(1,0), (0,1)]) sage: f = Fan([cone1, cone2])
Now we check if some cones are in this fan. First, we make sure that the order of rays of the input cone does not matter (``check=False`` option ensures that rays of these cones will be listed exactly as they are given)::
sage: f.contains(Cone([(1,0), (0,1)], check=False)) True sage: f.contains(Cone([(0,1), (1,0)], check=False)) True
Now we check that a non-generating cone is in our fan::
sage: f.contains(Cone([(1,0)])) True sage: Cone([(1,0)]) in f # equivalent to the previous command True
Finally, we test some cones which are not in this fan::
sage: f.contains(Cone([(1,1)])) False sage: f.contains(Cone([(1,0), (-0,1)])) True
A point is not a cone::
sage: n = f.lattice()(1,1); n N(1, 1) sage: f.contains(n) False """
def embed(self, cone): r""" Return the cone equivalent to the given one, but sitting in ``self``.
You may need to use this method before calling methods of ``cone`` that depend on the ambient structure, such as :meth:`~sage.geometry.cone.ConvexRationalPolyhedralCone.ambient_ray_indices` or :meth:`~sage.geometry.cone.ConvexRationalPolyhedralCone.facet_of`. The cone returned by this method will have ``self`` as ambient. If ``cone`` does not represent a valid cone of ``self``, ``ValueError`` exception is raised.
.. NOTE::
This method is very quick if ``self`` is already the ambient structure of ``cone``, so you can use without extra checks and performance hit even if ``cone`` is likely to sit in ``self`` but in principle may not.
INPUT:
- ``cone`` -- a :class:`cone <sage.geometry.cone.ConvexRationalPolyhedralCone>`.
OUTPUT:
- a :class:`cone of fan <Cone_of_fan>`, equivalent to ``cone`` but sitting inside ``self``.
EXAMPLES:
Let's take a 3-d fan generated by a cone on 4 rays::
sage: f = Fan([Cone([(1,0,1), (0,1,1), (-1,0,1), (0,-1,1)])])
Then any ray generates a 1-d cone of this fan, but if you construct such a cone directly, it will not "sit" inside the fan::
sage: ray = Cone([(0,-1,1)]) sage: ray 1-d cone in 3-d lattice N sage: ray.ambient_ray_indices() (0,) sage: ray.adjacent() () sage: ray.ambient() 1-d cone in 3-d lattice N
If we want to operate with this ray as a part of the fan, we need to embed it first::
sage: e_ray = f.embed(ray) sage: e_ray 1-d cone of Rational polyhedral fan in 3-d lattice N sage: e_ray.rays() N(0, -1, 1) in 3-d lattice N sage: e_ray is ray False sage: e_ray.is_equivalent(ray) True sage: e_ray.ambient_ray_indices() (3,) sage: e_ray.adjacent() (1-d cone of Rational polyhedral fan in 3-d lattice N, 1-d cone of Rational polyhedral fan in 3-d lattice N) sage: e_ray.ambient() Rational polyhedral fan in 3-d lattice N
Not every cone can be embedded into a fixed fan::
sage: f.embed(Cone([(0,0,1)])) Traceback (most recent call last): ... ValueError: 1-d cone in 3-d lattice N does not belong to Rational polyhedral fan in 3-d lattice N! sage: f.embed(Cone([(1,0,1), (-1,0,1)])) Traceback (most recent call last): ... ValueError: 2-d cone in 3-d lattice N does not belong to Rational polyhedral fan in 3-d lattice N! """ # Compute ray indices. # Get the smallest cone containing them # If there is a cone containing all of the rays of the given cone, # they must be among its generating rays and we only need to worry # if there are any extra ones.
@cached_method def Gale_transform(self): r""" Return the Gale transform of ``self``.
OUTPUT:
A matrix over `ZZ`.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.Gale_transform() [ 1 1 0 0 -2] [ 0 0 1 1 -2] sage: _.base_ring() Integer Ring """
def generating_cone(self, n): r""" Return the ``n``-th generating cone of ``self``.
INPUT:
- ``n`` -- integer, the index of a generating cone.
OUTPUT:
- :class:`cone of fan<Cone_of_fan>`.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.generating_cone(0) 2-d cone of Rational polyhedral fan in 2-d lattice N """
def generating_cones(self): r""" Return generating cones of ``self``.
OUTPUT:
- :class:`tuple` of :class:`cones of fan<Cone_of_fan>`.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.generating_cones() (2-d cone of Rational polyhedral fan in 2-d lattice N, 2-d cone of Rational polyhedral fan in 2-d lattice N, 2-d cone of Rational polyhedral fan in 2-d lattice N, 2-d cone of Rational polyhedral fan in 2-d lattice N) sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.generating_cones() (2-d cone of Rational polyhedral fan in 2-d lattice N, 1-d cone of Rational polyhedral fan in 2-d lattice N) """
@cached_method def vertex_graph(self): """ Return the graph of 1- and 2-cones.
OUTPUT:
An edge-colored graph. The vertices correspond to the 1-cones (i.e. rays) of the fan. Two vertices are joined by an edge iff the rays span a 2-cone of the fan. The edges are colored by pairs of integers that classify the 2-cones up to `GL(2,\ZZ)` transformation, see :func:`~sage.geometry.cone.classify_cone_2d`.
EXAMPLES::
sage: dP8 = toric_varieties.dP8() sage: g = dP8.fan().vertex_graph() sage: g Graph on 4 vertices sage: set(dP8.fan(1)) == set(g.vertices()) True sage: g.edge_labels() # all edge labels the same since every cone is smooth [(1, 0), (1, 0), (1, 0), (1, 0)]
sage: g = toric_varieties.Cube_deformation(10).fan().vertex_graph() sage: g.automorphism_group().order() 48 sage: g.automorphism_group(edge_labels=True).order() 4 """
def is_complete(self): r""" Check if ``self`` is complete.
A rational polyhedral fan is *complete* if its cones fill the whole space.
OUTPUT:
- ``True`` if ``self`` is complete and ``False`` otherwise.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.is_complete() True sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.is_complete() False """ # Now we know that all generating cones are full-dimensional. # Then boundary cones are (d-1)-dimensional.
def is_equivalent(self, other): r""" Check if ``self`` is "mathematically" the same as ``other``.
INPUT:
- ``other`` - fan.
OUTPUT:
- ``True`` if ``self`` and ``other`` define the same fans as collections of equivalent cones in the same lattice, ``False`` otherwise.
There are three different equivalences between fans `F_1` and `F_2` in the same lattice:
#. They have the same rays in the same order and the same generating cones in the same order. This is tested by ``F1 == F2``. #. They have the same rays and the same generating cones without taking into account any order. This is tested by ``F1.is_equivalent(F2)``. #. They are in the same orbit of `GL(n,\ZZ)` (and, therefore, correspond to isomorphic toric varieties). This is tested by ``F1.is_isomorphic(F2)``.
Note that :meth:`virtual_rays` are included into consideration for all of the above equivalences.
EXAMPLES::
sage: fan1 = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1,-1)], ....: check=False) sage: fan2 = Fan(cones=[(2,1), (0,2)], ....: rays=[(1,0), (-1,-1), (0,1)], ....: check=False) sage: fan3 = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1,1)], ....: check=False) sage: fan1 == fan2 False sage: fan1.is_equivalent(fan2) True sage: fan1 == fan3 False sage: fan1.is_equivalent(fan3) False """ or self.dim() != other.dim() or self.ngenerating_cones() != other.ngenerating_cones() or self.rays().set() != other.rays().set() or self.virtual_rays().set() != other.virtual_rays().set()): # Now we need to really compare cones, which can take a while == sorted(sorted(cone.rays()) for cone in other)
def is_isomorphic(self, other): r""" Check if ``self`` is in the same `GL(n, \ZZ)`-orbit as ``other``.
There are three different equivalences between fans `F_1` and `F_2` in the same lattice:
#. They have the same rays in the same order and the same generating cones in the same order. This is tested by ``F1 == F2``. #. They have the same rays and the same generating cones without taking into account any order. This is tested by ``F1.is_equivalent(F2)``. #. They are in the same orbit of `GL(n,\ZZ)` (and, therefore, correspond to isomorphic toric varieties). This is tested by ``F1.is_isomorphic(F2)``.
Note that :meth:`virtual_rays` are included into consideration for all of the above equivalences.
INPUT:
- ``other`` -- a :class:`fan <RationalPolyhedralFan>`.
OUTPUT:
- ``True`` if ``self`` and ``other`` are in the same `GL(n, \ZZ)`-orbit, ``False`` otherwise.
.. SEEALSO::
If you want to obtain the actual fan isomorphism, use :meth:`isomorphism`.
EXAMPLES:
Here we pick an `SL(2,\ZZ)` matrix ``m`` and then verify that the image fan is isomorphic::
sage: rays = ((1, 1), (0, 1), (-1, -1), (1, 0)) sage: cones = [(0,1), (1,2), (2,3), (3,0)] sage: fan1 = Fan(cones, rays) sage: m = matrix([[-2,3],[1,-1]]) sage: fan2 = Fan(cones, [vector(r)*m for r in rays]) sage: fan1.is_isomorphic(fan2) True sage: fan1.is_equivalent(fan2) False sage: fan1 == fan2 False
These fans are "mirrors" of each other::
sage: fan1 = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,1), (-1,-1)], ....: check=False) sage: fan2 = Fan(cones=[(0,1), (1,2)], ....: rays=[(1,0), (0,-1), (-1,1)], ....: check=False) sage: fan1 == fan2 False sage: fan1.is_equivalent(fan2) False sage: fan1.is_isomorphic(fan2) True sage: fan1.is_isomorphic(fan1) True """ fan_isomorphic_necessary_conditions, fan_isomorphism_generator return False else: return other._2d_echelon_form() in self._2d_echelon_forms() except StopIteration: return False
@cached_method def _2d_echelon_forms(self): """ Return all echelon forms of the cyclically ordered rays of a 2-d fan.
OUTPUT:
A set of integer matrices.
EXAMPLES::
sage: fan = toric_varieties.dP8().fan() sage: fan._2d_echelon_forms() frozenset({[ 1 0 -1 -1] [ 0 1 0 -1], [ 1 0 -1 0] [ 0 1 -1 -1], [ 1 0 -1 0] [ 0 1 1 -1], [ 1 0 -1 1] [ 0 1 0 -1]}) """
@cached_method def _2d_echelon_form(self): """ Return the echelon form of one particular cyclic order of rays of a 2-d fan.
OUTPUT:
An integer matrix whose columns are the rays in the echelon form.
EXAMPLES::
sage: fan = toric_varieties.dP8().fan() sage: fan._2d_echelon_form() [ 1 0 -1 -1] [ 0 1 0 -1] """
def isomorphism(self, other): r""" Return a fan isomorphism from ``self`` to ``other``.
INPUT:
- ``other`` -- fan.
OUTPUT:
A fan isomorphism. If no such isomorphism exists, a :class:`~sage.geometry.fan_isomorphism.FanNotIsomorphicError` is raised.
EXAMPLES::
sage: rays = ((1, 1), (0, 1), (-1, -1), (3, 1)) sage: cones = [(0,1), (1,2), (2,3), (3,0)] sage: fan1 = Fan(cones, rays) sage: m = matrix([[-2,3],[1,-1]]) sage: fan2 = Fan(cones, [vector(r)*m for r in rays])
sage: fan1.isomorphism(fan2) Fan morphism defined by the matrix [-2 3] [ 1 -1] Domain fan: Rational polyhedral fan in 2-d lattice N Codomain fan: Rational polyhedral fan in 2-d lattice N
sage: fan2.isomorphism(fan1) Fan morphism defined by the matrix [1 3] [1 2] Domain fan: Rational polyhedral fan in 2-d lattice N Codomain fan: Rational polyhedral fan in 2-d lattice N
sage: fan1.isomorphism(toric_varieties.P2().fan()) Traceback (most recent call last): ... FanNotIsomorphicError """
def is_simplicial(self): r""" Check if ``self`` is simplicial.
A rational polyhedral fan is **simplicial** if all of its cones are, i.e. primitive vectors along generating rays of every cone form a part of a *rational* basis of the ambient space.
OUTPUT:
- ``True`` if ``self`` is simplicial and ``False`` otherwise.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.is_simplicial() True sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.is_simplicial() True
In fact, any fan in a two-dimensional ambient space is simplicial. This is no longer the case in dimension three::
sage: fan = NormalFan(lattice_polytope.cross_polytope(3)) sage: fan.is_simplicial() False sage: fan.generating_cone(0).nrays() 4 """
@cached_method def is_smooth(self, codim=None): r""" Check if ``self`` is smooth.
A rational polyhedral fan is **smooth** if all of its cones are, i.e. primitive vectors along generating rays of every cone form a part of an *integral* basis of the ambient space. In this case the corresponding toric variety is smooth.
A fan in an `n`-dimensional lattice is smooth up to codimension `c` if all cones of codimension greater than or equal to `c` are smooth, i.e. if all cones of dimension less than or equal to `n-c` are smooth. In this case the singular set of the corresponding toric variety is of dimension less than `c`.
INPUT:
- ``codim`` -- codimension in which smoothness has to be checked, by default complete smoothness will be checked.
OUTPUT:
- ``True`` if ``self`` is smooth (in codimension ``codim``, if it was given) and ``False`` otherwise.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.is_smooth() True sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.is_smooth() True sage: fan = NormalFan(lattice_polytope.cross_polytope(2)) sage: fan.is_smooth() False sage: fan.is_smooth(codim=1) True sage: fan.generating_cone(0).rays() N(-1, -1), N(-1, 1) in 2-d lattice N sage: fan.generating_cone(0).rays().matrix().det() -2 """ self.is_smooth(codim + 1)
def make_simplicial(self, **kwds): r""" Construct a simplicial fan subdividing ``self``.
It is a synonym for :meth:`subdivide` with ``make_simplicial=True`` option.
INPUT:
- this functions accepts only keyword arguments. See :meth:`subdivide` for documentation.
OUTPUT:
- :class:`rational polyhedral fan <sage.geometry.fan.RationalPolyhedralFan>`.
EXAMPLES::
sage: fan = NormalFan(lattice_polytope.cross_polytope(3)) sage: fan.is_simplicial() False sage: fan.ngenerating_cones() 6 sage: new_fan = fan.make_simplicial() sage: new_fan.is_simplicial() True sage: new_fan.ngenerating_cones() 12 """
def ngenerating_cones(self): r""" Return the number of generating cones of ``self``.
OUTPUT:
- integer.
EXAMPLES::
sage: fan = toric_varieties.P1xP1().fan() sage: fan.ngenerating_cones() 4 sage: cone1 = Cone([(1,0), (0,1)]) sage: cone2 = Cone([(-1,0)]) sage: fan = Fan([cone1, cone2]) sage: fan.ngenerating_cones() 2 """
def plot(self, **options): r""" Plot ``self``.
INPUT:
- any options for toric plots (see :func:`toric_plotter.options <sage.geometry.toric_plotter.options>`), none are mandatory.
OUTPUT:
- a plot.
EXAMPLES::
sage: fan = toric_varieties.dP6().fan() sage: fan.plot() Graphics object consisting of 31 graphics primitives """
def subdivide(self, new_rays=None, make_simplicial=False, algorithm="default", verbose=False): r""" Construct a new fan subdividing ``self``.
INPUT:
- ``new_rays`` - list of new rays to be added during subdivision, each ray must be a list or a vector. May be empty or ``None`` (default);
- ``make_simplicial`` - if ``True``, the returned fan is guaranteed to be simplicial, default is ``False``;
- ``algorithm`` - string with the name of the algorithm used for subdivision. Currently there is only one available algorithm called "default";
- ``verbose`` - if ``True``, some timing information may be printed during the process of subdivision.
OUTPUT:
- :class:`rational polyhedral fan <sage.geometry.fan.RationalPolyhedralFan>`.
Currently the "default" algorithm corresponds to iterative stellar subdivision for each ray in ``new_rays``.
EXAMPLES::
sage: fan = NormalFan(lattice_polytope.cross_polytope(3)) sage: fan.is_simplicial() False sage: fan.ngenerating_cones() 6 sage: fan.nrays() 8 sage: new_fan = fan.subdivide(new_rays=[(1,0,0)]) sage: new_fan.is_simplicial() False sage: new_fan.ngenerating_cones() 9 sage: new_fan.nrays() 9
TESTS:
We check that :trac:`11902` is fixed::
sage: fan = toric_varieties.P2().fan() sage: fan.subdivide(new_rays=[(0,0)]) Traceback (most recent call last): ... ValueError: the origin cannot be used for fan subdivision! """ # Maybe these decisions should be done inside the algorithms # We can figure it out once we have at least two of them. else: if ray not in self.rays().set()) raise ValueError('"%s" is an unknown subdivision algorithm!' % algorithm)
def virtual_rays(self, *args): r""" Return (some of the) virtual rays of ``self``.
Let `N` be the `D`-dimensional :meth:`~sage.geometry.cone.IntegralRayCollection.lattice` of a `d`-dimensional fan `\Sigma` in `N_\RR`. Then the corresponding toric variety is of the form `X \times (\CC^*)^{D-d}`. The actual :meth:`~sage.geometry.cone.IntegralRayCollection.rays` of `\Sigma` give a canonical choice of homogeneous coordinates on `X`. This function returns an arbitrary but fixed choice of virtual rays corresponding to a (non-canonical) choice of homogeneous coordinates on the torus factor. Combinatorially primitive integral generators of virtual rays span the `D-d` dimensions of `N_\QQ` "missed" by the actual rays. (In general addition of virtual rays is not sufficient to span `N` over `\ZZ`.)
.. NOTE::
You may use a particular choice of virtual rays by passing optional argument ``virtual_rays`` to the :func:`Fan` constructor.
INPUT:
- ``ray_list`` -- a list of integers, the indices of the requested virtual rays. If not specified, all virtual rays of ``self`` will be returned.
OUTPUT:
- a :class:`~sage.geometry.point_collection.PointCollection` of primitive integral ray generators. Usually (if the fan is full-dimensional) this will be empty.
EXAMPLES::
sage: f = Fan([Cone([(1,0,1,0), (0,1,1,0)])]) sage: f.virtual_rays() N(0, 0, 0, 1), N(0, 0, 1, 0) in 4-d lattice N
sage: f.rays() N(1, 0, 1, 0), N(0, 1, 1, 0) in 4-d lattice N
sage: f.virtual_rays([0]) N(0, 0, 0, 1) in 4-d lattice N
You can also give virtual ray indices directly, without packing them into a list::
sage: f.virtual_rays(0) N(0, 0, 0, 1) in 4-d lattice N
Make sure that :trac:`16344` is fixed and one can compute the virtual rays of fans in non-saturated lattices::
sage: N = ToricLattice(1) sage: B = N.submodule([(2,)]).basis() sage: f = Fan([Cone([B[0]])]) sage: len(f.virtual_rays()) 0
TESTS::
sage: N = ToricLattice(4) sage: for i in range(10): ....: c = Cone([N.random_element() for j in range(i/2)], lattice=N) ....: f = Fan([c]) ....: assert matrix(f.rays() + f.virtual_rays()).rank() == 4 ....: assert f.dim() + len(f.virtual_rays()) == 4 """ else:
def primitive_collections(self): r""" Return the primitive collections.
OUTPUT:
Returns the subsets `\{i_1,\dots,i_k\} \subset \{ 1,\dots,n\}` such that
* The points `\{p_{i_1},\dots,p_{i_k}\}` do not span a cone of the fan.
* If you remove any one `p_{i_j}` from the set, then they do span a cone of the fan.
.. NOTE::
By replacing the multiindices `\{i_1,\dots,i_k\}` of each primitive collection with the monomials `x_{i_1}\cdots x_{i_k}` one generates the Stanley-Reisner ideal in `\ZZ[x_1,\dots]`.
REFERENCES:
..
V.V. Batyrev, On the classification of smooth projective toric varieties, Tohoku Math.J. 43 (1991), 569-585
EXAMPLES::
sage: fan = Fan([[0,1,3],[3,4],[2,0],[1,2,4]], [(-3, -2, 1), (0, 0, 1), (3, -2, 1), (-1, -1, 1), (1, -1, 1)]) sage: fan.primitive_collections() [frozenset({0, 4}), frozenset({2, 3}), frozenset({0, 1, 2}), frozenset({1, 3, 4})] """
# Generators of SR are index sets I = {i1, ..., ik} # called "primitive collections" such that # 1) I is not contained in a face # 2) if you remove any one entry j, then I-{j} is contained in a facet
else:
def Stanley_Reisner_ideal(self, ring): """ Return the Stanley-Reisner ideal.
INPUT:
- A polynomial ring in ``self.nrays()`` variables.
OUTPUT:
- The Stanley-Reisner ideal in the given polynomial ring.
EXAMPLES::
sage: fan = Fan([[0,1,3],[3,4],[2,0],[1,2,4]], [(-3, -2, 1), (0, 0, 1), (3, -2, 1), (-1, -1, 1), (1, -1, 1)]) sage: fan.Stanley_Reisner_ideal( PolynomialRing(QQ,5,'A, B, C, D, E') ) Ideal (A*E, C*D, A*B*C, B*D*E) of Multivariate Polynomial Ring in A, B, C, D, E over Rational Field """
def linear_equivalence_ideal(self, ring): """ Return the ideal generated by linear relations
INPUT:
- A polynomial ring in ``self.nrays()`` variables.
OUTPUT:
Returns the ideal, in the given ``ring``, generated by the linear relations of the rays. In toric geometry, this corresponds to rational equivalence of divisors.
EXAMPLES::
sage: fan = Fan([[0,1,3],[3,4],[2,0],[1,2,4]], [(-3, -2, 1), (0, 0, 1), (3, -2, 1), (-1, -1, 1), (1, -1, 1)]) sage: fan.linear_equivalence_ideal( PolynomialRing(QQ,5,'A, B, C, D, E') ) Ideal (-3*A + 3*C - D + E, -2*A - 2*C - D - E, A + B + C + D + E) of Multivariate Polynomial Ring in A, B, C, D, E over Rational Field """ for i in range(0, self.nrays()) ]) )
def oriented_boundary(self, cone): r""" Return the facets bounding ``cone`` with their induced orientation.
INPUT:
- ``cone`` -- a cone of the fan or the whole fan.
OUTPUT:
The boundary cones of ``cone`` as a formal linear combination of cones with coefficients `\pm 1`. Each summand is a facet of ``cone`` and the coefficient indicates whether their (chosen) orientation argrees or disagrees with the "outward normal first" boundary orientation. Note that the orientation of any individual cone is arbitrary. This method once and for all picks orientations for all cones and then computes the boundaries relative to that chosen orientation.
If ``cone`` is the fan itself, the generating cones with their orientation relative to the ambient space are returned.
See :meth:`complex` for the associated chain complex. If you do not require the orientation, use :meth:`cone.facets() <sage.geometry.cone.ConvexRationalPolyhedralCone.facets>` instead.
EXAMPLES::
sage: fan = toric_varieties.P(3).fan() sage: cone = fan(2)[0] sage: bdry = fan.oriented_boundary(cone); bdry 1-d cone of Rational polyhedral fan in 3-d lattice N - 1-d cone of Rational polyhedral fan in 3-d lattice N sage: bdry[0] (1, 1-d cone of Rational polyhedral fan in 3-d lattice N) sage: bdry[1] (-1, 1-d cone of Rational polyhedral fan in 3-d lattice N) sage: fan.oriented_boundary(bdry[0][1]) -0-d cone of Rational polyhedral fan in 3-d lattice N sage: fan.oriented_boundary(bdry[1][1]) -0-d cone of Rational polyhedral fan in 3-d lattice N
If you pass the fan itself, this method returns the orientation of the generating cones which is determined by the order of the rays in :meth:`cone.ray_basis() <sage.geometry.cone.IntegralRayCollection.ray_basis>` ::
sage: fan.oriented_boundary(fan) -3-d cone of Rational polyhedral fan in 3-d lattice N + 3-d cone of Rational polyhedral fan in 3-d lattice N - 3-d cone of Rational polyhedral fan in 3-d lattice N + 3-d cone of Rational polyhedral fan in 3-d lattice N sage: [cone.rays().basis().matrix().det() ....: for cone in fan.generating_cones()] [-1, 1, -1, 1]
A non-full dimensional fan::
sage: cone = Cone([(4,5)]) sage: fan = Fan([cone]) sage: fan.oriented_boundary(cone) 0-d cone of Rational polyhedral fan in 2-d lattice N sage: fan.oriented_boundary(fan) 1-d cone of Rational polyhedral fan in 2-d lattice N
TESTS::
sage: fan = toric_varieties.P2().fan() sage: trivial_cone = fan(0)[0] sage: fan.oriented_boundary(trivial_cone) 0 """
# Fix (arbitrary) orientations of the generating cones. Induced # by ambient space orientation for full-dimensional cones else:
# The orientation of each facet is arbitrary, but the # partition of the boundary in positively and negatively # oriented facets is not. .difference(set(facet.ambient_ray_indices()))
def complex(self, base_ring=ZZ, extended=False): r""" Return the chain complex of the fan.
To a `d`-dimensional fan `\Sigma`, one can canonically associate a chain complex `K^\bullet`
.. MATH::
0 \longrightarrow \ZZ^{\Sigma(d)} \longrightarrow \ZZ^{\Sigma(d-1)} \longrightarrow \cdots \longrightarrow \ZZ^{\Sigma(0)} \longrightarrow 0
where the leftmost non-zero entry is in degree `0` and the rightmost entry in degree `d`. See [Klyachko]_, eq. (3.2). This complex computes the homology of `|\Sigma|\subset N_\RR` with arbitrary support,
.. MATH::
H_i(K) = H_{d-i}(|\Sigma|, \ZZ)_{\text{non-cpct}}
For a complete fan, this is just the non-compactly supported homology of `\RR^d`. In this case, `H_0(K)=\ZZ` and `0` in all non-zero degrees.
For a complete fan, there is an extended chain complex
.. MATH::
0 \longrightarrow \ZZ \longrightarrow \ZZ^{\Sigma(d)} \longrightarrow \ZZ^{\Sigma(d-1)} \longrightarrow \cdots \longrightarrow \ZZ^{\Sigma(0)} \longrightarrow 0
where we take the first `\ZZ` term to be in degree -1. This complex is an exact sequence, that is, all homology groups vanish.
The orientation of each cone is chosen as in :meth:`oriented_boundary`.
INPUT:
- ``extended`` -- Boolean (default:False). Whether to construct the extended complex, that is, including the `\ZZ`-term at degree -1 or not.
- ``base_ring`` -- A ring (default: ``ZZ``). The ring to use instead of `\ZZ`.
OUTPUT:
The complex associated to the fan as a :class:`ChainComplex <sage.homology.chain_complex.ChainComplex>`. Raises a ``ValueError`` if the extended complex is requested for a non-complete fan.
EXAMPLES::
sage: fan = toric_varieties.P(3).fan() sage: K_normal = fan.complex(); K_normal Chain complex with at most 4 nonzero terms over Integer Ring sage: K_normal.homology() {0: Z, 1: 0, 2: 0, 3: 0} sage: K_extended = fan.complex(extended=True); K_extended Chain complex with at most 5 nonzero terms over Integer Ring sage: K_extended.homology() {-1: 0, 0: 0, 1: 0, 2: 0, 3: 0}
Homology computations are much faster over `\QQ` if you don't care about the torsion coefficients::
sage: toric_varieties.P2_123().fan().complex(extended=True, base_ring=QQ) Chain complex with at most 4 nonzero terms over Rational Field sage: _.homology() {-1: Vector space of dimension 0 over Rational Field, 0: Vector space of dimension 0 over Rational Field, 1: Vector space of dimension 0 over Rational Field, 2: Vector space of dimension 0 over Rational Field}
The extended complex is only defined for complete fans::
sage: fan = Fan([ Cone([(1,0)]) ]) sage: fan.is_complete() False sage: fan.complex(extended=True) Traceback (most recent call last): ... ValueError: The extended complex is only defined for complete fans!
The definition of the complex does not refer to the ambient space of the fan, so it does not distinguish a fan from the same fan embedded in a subspace::
sage: K1 = Fan([Cone([(-1,)]), Cone([(1,)])]).complex() sage: K2 = Fan([Cone([(-1,0,0)]), Cone([(1,0,0)])]).complex() sage: K1 == K2 True
Things get more complicated for non-complete fans::
sage: fan = Fan([Cone([(1,1,1)]), ....: Cone([(1,0,0),(0,1,0)]), ....: Cone([(-1,0,0),(0,-1,0),(0,0,-1)])]) sage: fan.complex().homology() {0: 0, 1: 0, 2: Z x Z, 3: 0} sage: fan = Fan([Cone([(1,0,0),(0,1,0)]), ....: Cone([(-1,0,0),(0,-1,0),(0,0,-1)])]) sage: fan.complex().homology() {0: 0, 1: 0, 2: Z, 3: 0} sage: fan = Fan([Cone([(-1,0,0),(0,-1,0),(0,0,-1)])]) sage: fan.complex().homology() {0: 0, 1: 0, 2: 0, 3: 0} """
# add the extra entry for the extended complex
def discard_faces(cones): r""" Return the cones of the given list which are not faces of each other.
INPUT:
- ``cones`` -- a list of :class:`cones <sage.geometry.cone.ConvexRationalPolyhedralCone>`.
OUTPUT:
- a list of :class:`cones <sage.geometry.cone.ConvexRationalPolyhedralCone>`, sorted by dimension in decreasing order.
EXAMPLES:
Consider all cones of a fan::
sage: Sigma = toric_varieties.P2().fan() sage: cones = flatten(Sigma.cones()) sage: len(cones) 7
Most of them are not necessary to generate this fan::
sage: from sage.geometry.fan import discard_faces sage: len(discard_faces(cones)) 3 sage: Sigma.ngenerating_cones() 3 """ # Convert to a list or make a copy, so that the input is unchanged.
_discard_faces = discard_faces # Due to a name conflict in Fan constructor |