Rational polyhedral fans#

This module was designed as a part of the framework for toric varieties (variety, fano_variety). While the emphasis is on complete full-dimensional fans, arbitrary fans are supported. Work with distinct lattices. The default lattice is ToricLattice \(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 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 Cone() and then combine them into a fan. See the documentation of Fan() for details.

In 2 dimensions there is a unique maximal fan determined by rays, and you can use 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 lattice polytopes: FaceFan() and 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 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 do not 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 cone_lattice():

sage: L = fan1.cone_lattice()
sage: L
Finite lattice 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 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)                                          # optional - palp
sage: rays = [cube.point(p) for p in sk]                                    # optional - palp
sage: fan4 = fan3.subdivide(new_rays=rays)                                  # optional - palp
sage: fan4.is_smooth()                                                      # optional - palp
True

Let’s see how “different” are fan2 and fan4:

sage: fan2.ngenerating_cones()
6
sage: fan2.nrays()
8
sage: fan4.ngenerating_cones()                                              # optional - palp
48
sage: fan4.nrays()                                                          # optional - palp
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!)

class sage.geometry.fan.Cone_of_fan(ambient, ambient_ray_indices)#

Bases: ConvexRationalPolyhedralCone

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” cones, 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()                               # optional - palp
sage: cone = fan.generating_cone(0); cone                               # optional - palp
2-d cone of Rational polyhedral fan in 2-d lattice N
sage: cone.ambient_ray_indices()                                        # optional - palp
(0, 2)
sage: cone.star_generator_indices()                                     # optional - palp
(0,)

star_generator_indices()#

Return indices of generating cones of the “ambient fan” containing self.

OUTPUT:

increasing tuple of integers.

EXAMPLES:

sage: P1xP1 = toric_varieties.P1xP1()                               # optional - palp
sage: cone = P1xP1.fan().generating_cone(0)                         # optional - palp
sage: cone.star_generator_indices()                                 # optional - palp
(0,)

star_generators()#

Return indices of generating cones of the “ambient fan” containing self.

OUTPUT:

increasing tuple of integers.

EXAMPLES:

sage: P1xP1 = toric_varieties.P1xP1()                               # optional - palp
sage: cone = P1xP1.fan().generating_cone(0)                         # optional - palp
sage: cone.star_generators()                                        # optional - palp
(2-d cone of Rational polyhedral fan in 2-d lattice N,)

sage.geometry.fan.FaceFan(polytope, lattice=None)#

Construct the face fan of the given rational polytope.

INPUT:

polytope – a polytope over \(\QQ\) or a lattice polytope. A (not necessarily full-dimensional) polytope containing the origin in its relative interior.
lattice – ToricLattice, \(\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:

rational polyhedral fan.

See also

If you want to obtain the actual fan isomorphism, use 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

is_simplicial()#

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()                           # optional - palp
sage: fan.is_simplicial()                                           # optional - palp
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

is_smooth(codim=None)#

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()                           # optional - palp
sage: fan.is_smooth()                                               # optional - palp
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

isomorphism(other)#

Return a fan isomorphism from self to other.

INPUT:

other – fan.

OUTPUT:

A fan isomorphism. If no such isomorphism exists, a 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())                  # optional - palp
Traceback (most recent call last):
...
FanNotIsomorphicError

linear_equivalence_ideal(ring)#

Return the ideal generated by linear relations.

INPUT:

A polynomial ring in self.nrays() variables.

OUTPUT:

Return 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

make_simplicial(**kwds)#

Construct a simplicial fan subdividing self.

It is a synonym for subdivide() with make_simplicial=True option.

INPUT:

this functions accepts only keyword arguments. See subdivide() for documentation.

OUTPUT:

rational polyhedral fan.

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

ngenerating_cones()#

Return the number of generating cones of self.

OUTPUT:

integer.

EXAMPLES:

sage: fan = toric_varieties.P1xP1().fan()                           # optional - palp
sage: fan.ngenerating_cones()                                       # optional - palp
4
sage: cone1 = Cone([(1,0), (0,1)])
sage: cone2 = Cone([(-1,0)])
sage: fan = Fan([cone1, cone2])
sage: fan.ngenerating_cones()
2

oriented_boundary(cone)#

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 agrees 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 complex() for the associated chain complex. If you do not require the orientation, use cone.facets() instead.

EXAMPLES:

sage: fan = toric_varieties.P(3).fan()                              # optional - palp
sage: cone = fan(2)[0]                                              # optional - palp
sage: bdry = fan.oriented_boundary(cone);  bdry                     # optional - palp
-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]                                                       # optional - palp
(-1, 1-d cone of Rational polyhedral fan in 3-d lattice N)
sage: bdry[1]                                                       # optional - palp
(1, 1-d cone of Rational polyhedral fan in 3-d lattice N)
sage: fan.oriented_boundary(bdry[0][1])                             # optional - palp
-0-d cone of Rational polyhedral fan in 3-d lattice N
sage: fan.oriented_boundary(bdry[1][1])                             # optional - palp
-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 cone.ray_basis()

sage: fan.oriented_boundary(fan)                                    # optional - palp
-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()                           # optional - palp
....:  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

plot(**options)#

Plot self.

INPUT:

any options for toric plots (see toric_plotter.options), none are mandatory.

OUTPUT:

a plot.

EXAMPLES:

sage: fan = toric_varieties.dP6().fan()                             # optional - palp
sage: fan.plot()                                                    # optional - palp sage.plot
Graphics object consisting of 31 graphics primitives

primitive_collections()#

Return the primitive collections.

OUTPUT:

Return 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:

[Bat1991]

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

subdivide(new_rays=None, make_simplicial=False, algorithm='default', verbose=False)#

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:

rational polyhedral fan.

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

support_contains(*args)#

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

toric_variety(*args, **kwds)#

Return the associated toric variety.

INPUT:

same arguments as ToricVariety()

OUTPUT:

a toric variety

This is equivalent to the command ToricVariety(self) and is provided only as a convenient alternative method to go from the fan to the associated toric variety.

EXAMPLES:

sage: Fan([Cone([(1,0)]), Cone([(0,1)])]).toric_variety()
2-d toric variety covered by 2 affine patches

vertex_graph()#

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 classify_cone_2d().

EXAMPLES:

sage: dP8 = toric_varieties.dP8()                                               # optional - palp sage.graphs
sage: g = dP8.fan().vertex_graph(); g                                           # optional - palp sage.graphs
Graph on 4 vertices
sage: set(dP8.fan(1)) == set(g.vertices(sort=False))                            # optional - palp sage.graphs
True
sage: g.edge_labels()  # all edge labels the same since every cone is smooth    # optional - palp sage.graphs
[(1, 0), (1, 0), (1, 0), (1, 0)]

sage: g = toric_varieties.Cube_deformation(10).fan().vertex_graph()             # optional - sage.graphs
sage: g.automorphism_group().order()                                            # optional - sage.graphs sage.groups
48
sage: g.automorphism_group(edge_labels=True).order()                            # optional - sage.graphs sage.groups
4

virtual_rays(*args)#

Return (some of the) virtual rays of self.

Let \(N\) be the \(D\)-dimensional 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 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 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 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(1, 0, 0, 0),
N(0, 0, 0, 1)
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(1, 0, 0, 0)
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(1, 0, 0, 0)
in 4-d lattice N

Make sure that trac ticket #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

sage.geometry.fan.discard_faces(cones)#

Return the cones of the given list which are not faces of each other.

INPUT:

cones – a list of cones.

OUTPUT:

a list of cones, sorted by dimension in decreasing order.

EXAMPLES:

Consider all cones of a fan:

sage: Sigma = toric_varieties.P2().fan()                                # optional - palp
sage: cones = flatten(Sigma.cones())                                    # optional - palp
sage: len(cones)                                                        # optional - palp
7

Most of them are not necessary to generate this fan:

sage: from sage.geometry.fan import discard_faces
sage: len(discard_faces(cones))                                         # optional - palp
3
sage: Sigma.ngenerating_cones()                                         # optional - palp
3

sage.geometry.fan.is_Fan(x)#

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(); fan                             # optional - palp
Rational polyhedral fan in 2-d lattice N
sage: is_Fan(fan)                                                       # optional - palp
True