application fan

This application deals with polyhedral fans. You can define a fan, e.g. via its RAYS and MAXIMAL_CONES and compute several properties like HASSE_DIAGRAM and F_VECTOR.

imports from:

• application common
• application graph
• application polytope

uses:

• application group
• application ideal
• application topaz

• DisjointStackyFan:
  This represents a stacky fan built from the orbit of a fan F under a group G that permutes the homogeneous coordinates of F's rays. It is assumed, but currently not checked, that the interior of F does not intersect the interiors of its images.

• HyperplaneArrangement:
  A hyperplane arrangement. The hyperplane arrangement is given by a matrix HYPERPLANES whose rows are the linear equations of the hyperplanes and an optional support cone. The support cone defaults to being the whole space. Duplicate hyperplanes are ignored, as well as hyperplanes that intersect the support cone trivially. The support cone is subdivided by the hyperplanes resulting in a fan CHAMBER_DECOMPOSITION.

• PlanarNet:
  A special big object class devoted to planar unfoldings of 3-polytopes. Its main functionality is the visualization.

• PolyhedralComplex:
  A polyhedral complex. The derivation from PolyhedralFan works like the derivation of Polytope from Cone.

• PolyhedralFan:
  A polyhedral fan. The current restriction is that each cone in the fan has to be pointed. This will be relaxed later. If a fan is specified via INPUT_RAYS and INPUT_CONES each input cone must list all the input rays incident. Once non-trivial linealities are allowed the following will apply: The RAYS always lie in a linear subspace which is complementary to the LINEALITY_SPACE.

• SubdivisionOfPoints:
  The inhomogeneous variant of SubdivisionOfVectors, similar to the derivation of PointConfiguration from VectorConfiguration.

• SubdivisionOfVectors:
  A subdivision of vectors, in contrast to PolyhedralFan this allows cells with interior points. Similar to the distinction between Cone and VectorConfiguration.

• Visual::PlanarNet:
  Visualization of a 3-polytope as a planar net.

• Visual::PolyhedralFan:
  Visualization of a polyhedral fan as a graph

These clients provide consistency checks, e.g. whether a given list of rays and cones defines a polyhedral fan.

check_complex_objects(Array<Polytope> polytopes)

Checks whether the Polytope objects form a polyhedral complex. If this is the case, returns that PolyhedralComplex.

Parameters:

Array<Polytope> polytopes

Options:

Bool verbose: prints information about the check.

Returns:

PolyhedralComplex

check_fan(Matrix rays, IncidenceMatrix cones)

Checks whether a given set of rays together with a list cones defines a polyhedral fan. If this is the case, the output is the PolyhedralFan defined by rays as INPUT_RAYS, cones as INPUT_CONES, lineality_space as LINEALITY_SPACE if this option is given.

Parameters:

Matrix rays

IncidenceMatrix cones

Options:

Matrix lineality_space: Common lineality space for the cones.

Bool verbose: prints information about the check.

Returns:

PolyhedralFan

check_fan_objects(Array<Cone> cones)

Checks whether the Cone objects form a polyhedral fan. If this is the case, returns that PolyhedralFan.

Parameters:

Array<Cone> cones

Options:

Bool verbose: prints information about the check.

Returns:

PolyhedralFan

All around Tight spans of finite metric spaces and their conections to polyhedral geometry

max_metric(Int n)

Compute a metric such that the f-vector of its tight span is maximal among all metrics with n points.

> See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)

Parameters:

Int n: the number of points

Returns:

Matrix

Example:

To compute the max-metric of five points and display the f-vector of its tight span, do this:

 > $M = max_metric(5);
 > $PC = metric_tight_span($M,extended=>1);
 > print $PC->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 16 20 5

metric_extended_tight_span(Matrix<Rational> M)

Computes a extended tight span which is a PolyhedralComplex with induced from a mertic.

Parameters:

Matrix<Rational> M: a metric

Returns:

PolyhedralComplex

Example:

To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:

 > $M = thrackle_metric(5);
 > $PC = metric_extended_tight_span($M);
 > print $PC->F_VECTOR;
 16 20 5

metric_tight_span(Matrix<Rational> M)

Computes a SubdivisionOfPoints with a weight function which is induced from a mertic.

Parameters:

Matrix<Rational> M: a metric

Options:

Bool extended: If true, the extended tight span is computed.

Returns:

SubdivisionOfPoints

Example:

To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:

 > $M = thrackle_metric(5);
 > $PC = metric_tight_span($M,extended=>1);
 > print $PC->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 16 20 5

min_metric(Int n)

Compute a metric such that the f-vector of its tight span is minimal among all metrics with n points.

> See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)

Parameters:

Int n: the number of points

Returns:

Matrix

Example:

To compute the min-metric of five points and display the f-vector of its tight span, do this:

 > $M = min_metric(5);
 > $PC = metric_tight_span($M,extended=>1);
 > print $PC->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 16 20 5

thrackle_metric(Int n)

Compute a thrackle metric on n points. This metric can be interpreted as a lifting function for the thrackle triangulation.

> See De Loera, Sturmfels and Thomas: Gröbner bases and triangulations of the second hypersimplex, Combinatorica 15 (1995)

Parameters:

Int n: the number of points

Returns:

Matrix

Example:

To compute the thrackle-metric of five points and display the f-vector of its tight span, do this:

 > $M = thrackle_metric(5);
 > $PC = metric_extended_tight_span($M);
 > print $PC->F_VECTOR;
 16 20 5

tight_span_max_metric(Int n)

Compute a SubdivisionOfPoints with a tight span of a metric such that the f-vector is maximal among all metrics with n points.

> See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)

Parameters:

Int n: the number of points

Returns:

SubdivisionOfPoints

Example:

To compute the f-vector of the tight span with maximal f-vector, do this:

 > print tight_span_max_metric(5)->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 11 15 5

tight_span_min_metric(Int n)

Compute a SubdivisionOfPoints with a tight span of a metric such that the f-vector is minimal among all metrics with n points.

> See Herrmann and Joswig: Bounds on the f-vectors of tight spans, Contrib. Discrete Math., Vol.2, (2007)

Parameters:

Int n: the number of points

Returns:

SubdivisionOfPoints

Example:

To compute the f-vector of the tight span with minimal f-vector, do this:

 > print tight_span_min_metric(5)->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 11 15 5

tight_span_thrackle_metric(Int n)

Compute SubdivisionOfPoints with a tight span of the thrackle metric on n points. This metric can be interpreted as a lifting function which induces the thrackle triangulation of the second hypersimplex.

> See De Loera, Sturmfels and Thomas: Gröbner bases and triangulations of the second hypersimplex, Combinatorica 15 (1995)

Parameters:

Int n: the number of points

Returns:

SubdivisionOfPoints

Example:

To compute the $f$-vector, do this:

 > print tight_span_min_metric(5)->POLYTOPAL_SUBDIVISION->TIGHT_SPAN->F_VECTOR;
 11 15 5

These functions capture geometric information of the object. Geometric properties depend on geometric information of the object, like, e.g., vertices or facets.

chamber_decomposition_brute_force

This function computes the CHAMBER_DECOMPOSITION of a given hyperplane arrangement in a brute force way, by just considering every possible signature. Since not every signature gives a valid cell, it is much cheaper to traverse the cells of CHAMBER_DECOMPOSITION by flipping the walls. This method is here for verifying results of our other algorithms.

generating_polyhedron_facets(PolyhedralFan P)

The facets of a polyhedron that has the fan P as its normal fan, or the empty matrix if no such polyhedron exists.

Parameters:

PolyhedralFan P

Returns:

Matrix<Scalar>

Example:

The face fan of the cross polytope is the normal fan of the cube; thus, to obtain the inequalities of the 3-cube from the 3-dimensional cross polytope we can do this:

 > $c = generating_polyhedron_facets(face_fan(cross(3)));

induced_subdivision<Scalar>(VectorConfiguration<Scalar> pc, Matrix<Scalar> R, Set I)

Calculate the subdivision induced on a point configuration by a height function h. The height function is specified as the sum of a set of rows of a matrix. Using the RAYS of the secondary_fan of the configuration works well.

Type Parameters:

Scalar: the underlying number type

Parameters:

VectorConfiguration<Scalar> pc: (or polytope/cone) the input configuration

Matrix<Scalar> R: a matrix such that R→cols() == pc→N_VECTORS

Set I: (or ARRAY) a set of indices that select rows from R

Options:

Bool verbose: print the final height function used=? Default 0

Returns:

Set<Set>

induced_subdivision

Calculate the subdivision induced on a polytope by a height function h.

These clients provide standard constructions for PolyhedralFan objects, e.g. from polytopes (face_fan or normal_fan) or from other fans (via projection, refinement or product).

chamber_decomposition_rs

Produce the chamber decomposition induced by a hyperplane arrangement

common_refinement(PolyhedralFan f1, PolyhedralFan f2)

Computes the common refinement of two fans. This is the fan made of all intersections of cones of the first fan with cones of the second fan. Note that the support of the result is the intersection of the supports of the input fans.

Parameters:

PolyhedralFan f1

PolyhedralFan f2

Returns:

PolyhedralFan

Example:

Two two-dimensional fans with different support

 > $s = simplex(2);
 > $c = new Polytope(POINTS=>[[1,0,0],[0,-1,0],[0,0,-1]]);
 > $f1 = normal_fan($s);
 > $f2 = normal_fan($c);
 > print $f1->RAYS;
 -1 -1
 1 0
 0 1

 > print $f1->MAXIMAL_CONES;
 {1 2}
 {0 2}
 {0 1}

 > print $f2->RAYS;
 -1 0
 0 -1

 > print $f2->MAXIMAL_CONES;
 {0 1}

 > $cc = common_refinement($f1,$f2);
 > print $cc->RAYS;
 -1 -1
 -1 0
 0 -1

 > print $cc->MAXIMAL_CONES;
 {0 1}
 {0 2}

face_fan<Coord>(Polytope p, Vector v)

Computes the face fan of p.

Type Parameters:

Coord

Parameters:

Polytope p

Vector v: a relative interior point of the polytope

Returns:

PolyhedralFan

face_fan<Coord>(Polytope p)

Computes the face fan of p. the polytope has to be CENTERED

Type Parameters:

Coord

Parameters:

Polytope p

Returns:

PolyhedralFan

fan_from_cones(Array<Cone> cones)

Construct a polyhedral fan from a list of Cone objects. No intersection checks are perfomed but the rays lists are canonicalized and merged. Warning: This might result in an invalid object if the input is not correct.

Parameters:

Array<Cone> cones

Returns:

PolyhedralFan

gfan_secondary_fan(Matrix M)

Call gfan to compute the secondary fan of a point configuration.

Parameters:

Matrix M: a matrix whose rows are the vectors in the configuration

Returns:

PolyhedralFan

Example:

Four points in the plane of which none three are on a line give us a secondary fan consisting of two opposing cones with 3-dimensional lineality:

 > $f = gfan_secondary_fan(new PointConfiguration(POINTS=>[[1,0,0],[1,1,0],[1,0,1],[1,1,1]]));
 > print $f->RAYS;
 -1 1 1 -1
 1 -1 -1 1

 > print $f->MAXIMAL_CONES;
 {0}
 {1}

 > print $f->LINEALITY_SPACE;
 1 0 0 -1
 0 1 0 1
 0 0 1 1

gfan_secondary_fan(PointConfiguration P)

Call gfan to compute the secondary fan of a point configuration.

Parameters:

PointConfiguration P

Returns:

PolyhedralFan

graph_associahedron_fan(Graph G)

Produce the dual fan of a graph associahedron.

Parameters:

Graph G: the input graph

Returns:

PolyhedralFan

groebner_fan(Ideal I)

Call gfan to compute the greobner fan of an ideal.

Parameters:

Ideal I: input ideal

Returns:

PolyhedralFan

intersection(PolyhedralFan F, Matrix H)

Construct a new fan as the intersection of given fan with a subspace.

Parameters:

PolyhedralFan F

Matrix H: equations of subspace

Returns:

PolyhedralFan

k_skeleton<Coord>(PolyhedralFan F, Int k)

Computes the k-skeleton of the polyhedral fan F, i.e. the subfan of F consisting of all cones of dimension ⇐k.

Type Parameters:

Coord

Parameters:

PolyhedralFan F

Int k: the desired top dimension

Returns:

PolyhedralFan

normal_fan<Coord>(Polytope p)

Computes the normal fan of p.

Type Parameters:

Coord

Parameters:

Polytope p

Returns:

PolyhedralFan

planar_net(Polytope p)

Computes a planar net of the 3-polytope p. Note that it is an open problem if such a planar net always exists.

• PROGRAM MIGHT TERMINATE WITH AN EXCEPTION *

If it does, please, notify the polymake team! Seriously.

Parameters:

Polytope p

Returns:

PlanarNet

product(PolyhedralFan F1, PolyhedralFan F2)

Construct a new polyhedral fan as the product of two given polyhedral fans F1 and F2.

Parameters:

PolyhedralFan F1

PolyhedralFan F2

Options:

Bool no_coordinates: only combinatorial information is handled

Returns:

PolyhedralFan

project_full(PolyhedralFan P)

Orthogonally project a fan to a coordinate subspace such that redundant columns are omitted, i.e., the affine hull of the support of the projection is full-dimensional, without changing the combinatorial type.

Parameters:

PolyhedralFan P

Options:

Bool no_labels: Do not copy VERTEX_LABELS to the projection. default: 0

Returns:

PolyhedralFan

Example:

x and y axis in 3-space

 > $f = new PolyhedralFan(INPUT_RAYS=>[[1,0,0],[0,1,0]], INPUT_CONES=>[[0],[1]]);
 > $pf = project_full($f);
 > print $pf->RAYS;
 1 0
 0 1

 > print $pf->MAXIMAL_CONES;
 {0}
 {1}

union_of_cones(Cone C …)

Construct a new polyhedral fan whose support is the union of given cones. Optional HyperplaneArrangemnt for further subdivision or support. Also applies to polytopes, via homogenization. The output is always homogeneous. Works only if all CONE_AMBIENT_DIM values are equal.

Parameters:

Cone C …: cones to be added to union

Options:

HyperplaneArrangement arr

Returns:

PolyhedralFan

Example:

 > $C = new Cone(INPUT_RAYS=>[[1,0],[2,3]]); $D = new Cone(INPUT_RAYS=>[[0,1],[3,2]]);
 > $U = union_of_cones($C,$D);
 > print rows_numbered($U->RAYS);
 0:1 2/3
 1:1 0
 2:1 3/2
 3:0 1

 > print $U->MAXIMAL_CONES;
 {0 1}
 {0 2}
 {2 3}

These clients provide constructions for HyperplaneArrangement objects.

arrangement_from_cones(Cone C …)

Construct a new hyperplane arrangement from the exterior descriptions of given cones. Optional HyperplaneArrangemnt for further subdivision or support. Also applies to polytopes, via homogenization. The output is always homogeneous. Works only if all CONE_AMBIENT_DIM values are equal.

Parameters:

Cone C …: cones to be added to arrangement

Options:

HyperplaneArrangement hyar

Returns:

HyperplaneArrangement

Example:

 > $C = new Cone(INPUT_RAYS=>[[1,0],[2,3]]); $D = new Cone(INPUT_RAYS=>[[0,1],[3,2]]);
 > $HA = arrangement_from_cones($C,$D);
 > print $HA->HYPERPLANES;
 3/2 -1
 0 1
 1 0
 -1 3/2

 > print $HA->get_attachment("N_INEQUALITIES_PER_CONE");
 2 2

 > print $HA->get_attachment("N_EQUATIONS_PER_CONE");
 0 0

braid_arrangement(Int d)

Produce the braid arrangement in dimension $d$

Parameters:

Int d: ambient dimension

Returns:

HyperplaneArrangement

Example:

 > $B = braid_arrangement(3);

facet_arrangement

hypersimplex_vertex_splits(Int k, Int d)

Produce the arrangement of vertex splits of the hypersimplex $ Δ(k,d) $

Parameters:

Int k: number of 1s

Int d: ambient dimension

Options:

Bool group

Bool no_vertices: do not compute vertices

Bool no_facets: do not compute facets

Bool no_vif: do not compute vertices in facets

Returns:

Polytope

Example:

This corresponds to the hypersimplex in dimension 4 with vertices with exactly two 1-entries and computes its symmetry group:

 > $H = hypersimplex_vertex_splits(2,4,group=>1);

These clients provide constructions for PolyhedralComplex objects.

complex_from_polytopes(Array<Polytope> polytopes)

Construct a polyhedral complex from a list of Polytope objects. No intersection checks are perfomed but the rays lists are canonicalized and merged. Warning: This might result in an invalid object if the input is not correct.

Parameters:

Array<Polytope> polytopes

Returns:

PolyhedralComplex

mixed_subdivision(Polytope P_0, Polytope P_1, Array<Set> VIF, Scalar t_0, Scalar t_1)

Create a weighted mixed subdivision of the scaled Minkowski sum of two polytopes, using the Cayley trick. The polytopes must have the same dimension, at least one of them must be pointed. The vertices of the first polytope P_0 are weighted with t_0, and the vertices of the second polytope P_1 with t_1. Default values are t_0=t_1=1.

Parameters:

Polytope P_0: the first polytope

Polytope P_1: the second polytope

Array<Set> VIF: the indices of the vertices of the mixed cells

Scalar t_0: the weight for the vertices of P_0; default 1

Scalar t_1: the weight for the vertices of P_1; default 1

Options:

Bool no_labels: Do not copy VERTEX_LABELS from the original polytopes. default: 0

Returns:

PolyhedralComplex

mixed_subdivision(Int m, Polytope C, Array<Set> a)

Create a weighted mixed subdivision of a Cayley embedding of a sequence of polytopes. Each vertex v of the i-th polytope is weighted with t_i, the i-th entry of the optional array t.

Parameters:

Int m: the number of polytopes giving rise to the Cayley embedding

Polytope C: the Cayley embedding of the input polytopes

Array<Set> a: triangulation of C

Options:

Vector<Scalar> t: scaling for the Cayley embedding; defaults to the all-1 vector

Bool no_labels: Do not copy VERTEX_LABELS from the original polytopes. default: 0

Returns:

PolyhedralComplex

mixed_subdivision(Array<Polytope> A, Array<Set> VIF)

Create a weighted mixed subdivision of a sequence (P1,…,Pm) of polytopes, using the Cayley trick. All polytopes must have the same dimension, at least one of them must be pointed. Each vertex v of the i-th polytope is weighted with t_i, the i-th entry of the optional array t.

Parameters:

Array<Polytope> A: the input polytopes

Array<Set> VIF: the indices of the vertices of the mixed cells

Options:

Vector<Scalar> t: scaling for the Cayley embedding; defaults to the all-1 vector

Bool no_labels: Do not copy VERTEX_LABELS from the original polytopes. default: 0

Returns:

PolyhedralComplex

tiling_quotient<Coord>(Polytope P, Polytope Q)

Calculates the quotient of P by Q+L, where Q+L is a lattice tiling. The result is a polytopal complex inside Q.

Type Parameters:

Coord

Parameters:

Polytope P: a polytope

Polytope Q: a polytope that tiles space

Returns:

PolyhedralComplex

These functions capture information of the object that is concerned with the action of permutation groups.

combinatorial_symmetries(PolyhedralFan f)

Compute the combinatorial symmetries (i.e., automorphisms of the face lattice) of a given fan f. They are stored in terms of a GROUP.RAYS_ACTION and a GROUP.MAXIMAL_CONES_ACTION property in f, and the GROUP.MAXIMAL_CONES_ACTION is also returned.

Parameters:

PolyhedralFan f

Returns:

PermutationAction

Example:

To get the ray symmetry group of the square and print its generators, type the following:

 > print combinatorial_symmetries(normal_fan(polytope::cube(2)))->GENERATORS;
 2 3 0 1
 1 0 3 2
 0 2 1 3

 > $f = normal_fan(polytope::cube(2)); combinatorial_symmetries($f);
 > print $f->GROUP->RAYS_ACTION->GENERATORS;
 0 1 3 2
 1 0 2 3
 2 3 0 1

 > print $f->GROUP->MAXIMAL_CONES_ACTION->GENERATORS;
 2 3 0 1
 1 0 3 2
 0 2 1 3

cones_action(PolyhedralFan f, Int k)

Returns the permutation action induced by the symmetry group of the fan f on the set of k-dimensional cones. This action is not stored as a property of f, because polymake doesn't support dynamic names of properties. Be aware that the set of k-dimensional cones itself is $f->CONES->[$k-1] .

Parameters:

PolyhedralFan f: the input fan

Int k: the dimension of the cones to induce the action on

Returns:

PermutationAction

Example:

Consider a 3-cube c. To calculate the induced action of Aut(c) on the set of 2-dimensional cones of the normal fan, type

 > $f = fan::normal_fan(polytope::cube(3, group=>1));
 > print fan::cones_action($f,2)->properties();
 name: CONES_ACTION(2)
 type: PermutationAction<Int, Rational>
 description: action induced on 2-dimensional cones
 
 GENERATORS
 0 3 4 1 2 5 7 6 8 10 9 11
 1 0 2 5 6 3 4 7 9 8 11 10
 0 2 1 4 3 8 9 10 5 6 7 11

 > print $f->CONES->[1];
 {2 4}
 {0 4}
 {0 2}
 {1 4}
 {1 2}
 {3 4}
 {0 3}
 {1 3}
 {2 5}
 {0 5}
 {1 5}
 {3 5}

orbit_complex(PolyhedralComplex input_complex, Array<Array<Int>> gens)

Constructs the orbit complex of a given polyhedral complex input_complex with respect to a given set of generators gens.

Parameters:

PolyhedralComplex input_complex: the generating complex of the orbit complex

Array<Array<Int>> gens: the generators of a permutation group that acts on the coordinates of the ambient space

Returns:

PolyhedralComplex

Example:

To calculate an orbit complex with respect to a group of coordinate permutations, follow these steps: First specify a seed complex:

 > $f=new PolyhedralComplex(VERTICES=>[[1,1,1],[1,1,0],[1,-1,-1]], MAXIMAL_POLYTOPES=>[[0,1],[1,2]]);

Then define the orbit complex by specifying a permutation action on coordinates:

 > $oc = orbit_complex($f, [[1,0]]);

The only properties of $oc defined so far reside in GROUP:

 > print $oc->GROUP->properties();
 type: Group as PolyhedralComplex<Rational>::GROUP
 
 COORDINATE_ACTION
 type: PermutationAction<Int, Rational> as PolyhedralComplex<Rational>::GROUP::COORDINATE_ACTION
 
 MAXIMAL_POLYTOPES_ACTION
 type: PermutationAction<Int, Rational> as PolyhedralComplex<Rational>::GROUP::MAXIMAL_POLYTOPES_ACTION

Now you can calculate the VERTICES and MAXIMAL_POLYTOPES of the orbit fan.

 > print $oc->VERTICES;
 1 1 1
 1 1 0
 1 -1 -1
 1 0 1

 > print $oc->N_MAXIMAL_POLYTOPES;
 4

orbit_complex(PolyhedralComplex input_complex, PermutationAction a)

Constructs the orbit complex of a given polyhedral complex input_complex with respect to a given group action a.

Parameters:

PolyhedralComplex input_complex: the generating complex of the orbit complex

PermutationAction a: the action of a permutation group on the coordinates of the ambient space

Returns:

PolyhedralComplex

Example:

To calculate an orbit complex with respect to a group of coordinate permutations, follow these steps: First specify a seed complex:

 > $f=new PolyhedralComplex(VERTICES=>[[1,1,1],[1,1,0],[1,1/2,1/4]], MAXIMAL_POLYTOPES=>[[0,2],[1,2]]);

Then define the orbit complex by specifying a matrix group action on the coordinates:

 > $oc = orbit_complex($f, polytope::cube(2,group=>1)->GROUP->MATRIX_ACTION);

The only properties of $oc defined so far reside in GROUP:

Now you can calculate the VERTICES and MAXIMAL_POLYTOPES of the orbit fan.

 > print $oc->VERTICES;
 1 1 1
 1 1 0
 1 1/2 1/4
 1 -1 -1
 1 -1 1
 1 1 -1
 1 -1 0
 1 0 -1
 1 0 1
 1 -1/2 -1/4
 1 -1/2 1/4
 1 -1/4 -1/2
 1 -1/4 1/2
 1 1/4 -1/2
 1 1/4 1/2
 1 1/2 -1/4

 > print $oc->N_MAXIMAL_POLYTOPES;
 16

orbit_fan(PolyhedralFan input_fan, Array<Array<Int>> gens)

Constructs the orbit fan of a given fan input_fan with respect to a given set of generators gens.

Parameters:

PolyhedralFan input_fan: the generating fan of the orbit fan

Array<Array<Int>> gens: the generators of a permutation group that acts on the coordinates of the ambient space

Returns:

PolyhedralFan

Example:

To calculate an orbit fan, follow these steps: First specify a seed fan:

 > $f=new PolyhedralFan(RAYS=>[[1,1],[1,0],[-1,-1]], MAXIMAL_CONES=>[[0,1],[1,2]]);

Then define the orbit fan by specifying coordinate permutations:

 > $of = orbit_fan($f,[[1,0]]);

The only properties of $of defined so far reside in GROUP:

 > print $of->GROUP->properties();
 name: unnamed#0
 type: Group as PolyhedralFan<Rational>::GROUP
 
 HOMOGENEOUS_COORDINATE_ACTION
 type: PermutationAction<Int, Rational>
 
 MAXIMAL_CONES_ACTION
 type: PermutationAction<Int, Rational> as PolyhedralFan<Rational>::GROUP::MAXIMAL_CONES_ACTION

Now you can calculate the RAYS and MAXIMAL_CONES of the orbit fan.

 > print $of->RAYS;
 1 1
 1 0
 -1 -1
 0 1

 > print $of->N_MAXIMAL_CONES;
 4

orbit_fan<Scalar>(PolyhedralFan input_fan, Array<Matrix<Scalar>> gens)

Constructs the orbit fan of a given fan input_fan with respect to a given set of matrix group generators gens.

Type Parameters:

Scalar: underlying number type

Parameters:

PolyhedralFan input_fan: the generating fan of the orbit fan

Array<Matrix<Scalar>> gens: the generators of a matrix group that acts on the ambient space

Returns:

PolyhedralFan

Example:

To calculate an orbit fan, follow these steps: First specify a seed fan:

 > $f=new PolyhedralFan(RAYS=>[[1,1,1],[1,1,0],[1,1/2,1/4]],MAXIMAL_CONES=>[[0,2],[1,2]]);

Then define the orbit fan by specifying a matrix group action:

 > $of = orbit_fan($f,polytope::cube(2,group=>1)->GROUP->MATRIX_ACTION);

The only properties of $of defined so far reside in GROUP:

 > print $of->GROUP->properties();
 name: unnamed#0
 type: Group as PolyhedralFan<Rational>::GROUP
 
 MATRIX_ACTION
 type: MatrixActionOnVectors<Rational>
 
 MAXIMAL_CONES_ACTION
 type: PermutationAction<Int, Rational> as PolyhedralFan<Rational>::GROUP::MAXIMAL_CONES_ACTION

Now you can calculate the RAYS and MAXIMAL_CONES of the orbit fan.

 > print $of->RAYS;
 1 1 1
 1 1 0
 1 1/2 1/4
 1 -1 -1
 1 -1 1
 1 1 -1
 1 -1 0
 1 0 -1
 1 0 1
 1 -1/2 -1/4
 1 -1/2 1/4
 1 -1/4 -1/2
 1 -1/4 1/2
 1 1/4 -1/2
 1 1/4 1/2
 1 1/2 -1/4

 > print $of->N_MAXIMAL_CONES;
 16

stacky_fundamental_domain(DisjointStackyFan F)

Find a fundamental domain for a cone modulo the action of a symmetry group. The fundamental domain will be a subcomplex, with connected DUAL_GRAPH, of the first barycentric subdivision that is found via a breadth-first search.

Parameters:

DisjointStackyFan F

Returns:

GeometricSimplicialComplex

stacky_le_fan(Cone C)

Calculate the stacky, locally embedded fan associated to a Cone and a group acting on homogeneous coordinates. This function turns the input Cone C into a PolyhedralFan PF, calculates the orbit_fan OF of PF, and packages the data in OF into the data for a DisjointStackyFan. No additional computation is executed at this point. The terminology 'locally embedded' references the fact that each constituent cone comes with a local embedding into the ambient space of the original Cone, but the faces of the constituent cones may intersect in complicated ways due to the identifications induced by the group action.

Parameters:

Cone C: the input cone, equipped with a GROUP→HOMOGENEOUS_COORDINATE_ACTION

Returns:

DisjointStackyFan

Example:

Consider the cone over the standard 2-simplex on which Z_2 acts by interchanging coordinates 0 and 1.

 > $c = new Cone(RAYS=>[[1,0,0],[0,1,0],[0,0,1]], GROUP=>new group::Group(HOMOGENEOUS_COORDINATE_ACTION=>new group::PermutationAction(GENERATORS=>[[1,0,2]])));

The stacky fan defined by this cone identifies the rays 0 and 1. The property STACKY_FACES records the orbits under the group action:

 > $sf = stacky_le_fan($c);
 > print $sf->STACKY_FACES;
 {{{0} {1}} {{2}}}
 {{{0 1}} {{0 2} {1 2}}}

 > print $sf->STACKY_F_VECTOR;
 2 2

These functions collect information about triangulations and other subdivisions of the object and properties usually computed from such, as the volume.

secondary_fan(VectorConfiguration V)

Calculate the secondary fan of a point or vector configuration, or polytope.

Parameters:

VectorConfiguration V: (or polytope) the input configuration

Options:

Array<Set> initial_subdivision: a seed subdivision of V

Matrix restrict_to: the equations defining a subspace that the secondary fan should be restricted to

Int seed: controls the outcome of the random number generator for generating a randomized initial subdivision

Returns:

PolyhedralFan<Scalar>

secondary_fan

These functions are for visualization.

splitstree(Visual::Object vis_obj …)

Call SplitsTree with the given visual objects.

Parameters:

Visual::Object vis_obj …: objects to display

Options:

String File: “filename” or “AUTO” Only create a NEXUS format file, don't start the GUI. The .nex suffix is automatically added to the file name. Specify AUTO if you want the filename be automatically derived from the drawing title. You can also use any expression allowed for the open function, including “-” for terminal output, “&HANDLE” for an already opened file handle, or “| program” for a pipe.

visual_splitstree(Matrix<Rational> M)

Visualize the splits of a finite metric space (that is, a planar image of a tight span). Calls SplitsTree.

Parameters:

Matrix<Rational> M: Matrix defining a metric

Options:

Array<String> taxa: Labels for the taxa

String name: Name of the drawing

Returns:

Visual::Object

Special purpose functions.

building_set(Array<Set> generators, Int n)

Produce a building set from a family of sets.

Parameters:

Array<Set> generators: the generators of the building set

Int n: the size of the ground set

Returns:

Set<Set<Int>>

cone_of_tubing(Graph G, Graph T)

Output the cone of a tubing

Parameters:

Graph G: the input graph

Graph T: the input tubing

Returns:

Cone

flip_tube(Graph G, Graph T, Int t)

Flip a tubing in a tube

Parameters:

Graph G: the input graph

Graph T: the input tubing

Int t: the tube to flip, identified by its root

Returns:

Graph

is_B_nested(Set<Set<Int>> check_me, Set<Set<Int>> B)

Check if a family of sets is nested wrt a given building set.

Parameters:

Set<Set<Int>> check_me: the would-be nested sets

Set<Set<Int>> B: the building set

Returns:

Bool

is_building_set(Set<Set<Int>> check_me, Int n)

Check if a family of sets is a building set.

Parameters:

Set<Set<Int>> check_me: the would-be building set

Int n: the size of the ground set

Returns:

Bool

tubes_of_graph(Graph G)

Output the set of all tubes of a graph

Parameters:

Graph G: the input graph

Returns:

Set<Set>

tubes_of_tubing(Graph G, Graph T)

Output the tubes of a tubing

Parameters:

Graph G: the input graph

Graph T: the input tubing

Returns:

Set<Set>

tubing_of_graph(Graph G)

Output one tubing of a graph

Parameters:

Graph G: the input graph

Returns:

Set<Set>

make_hyperplanes_unique_in_support

UNDOCUMENTED

SedentarityDecoration

UNDOCUMENTED