# application: topaz

The *TOP*ology *A*pplication *Z*oo deals with abstract simplicial complexes.
A complex is given as a list of facets. You can ask for its global properties (manifold recognition,
homology groups, etc.), explore the local vertex environment (stars, links, etc.), and make a lot
of constructions.

The visualization means are constrained, as they are mostly based on the GRAPH (1-skeleton) of a complex.

**imports from:**common, graph

**uses:**ideal

**Objects**

A geometric simplicial complex, i.e., a simplicial complex with a geometric realization.

*Scalar*is the numeric data type used for the coordinates.**derived from:**SimplicialComplex##### Type Parameters

Scalar default: Rational#### Properties of GeometricSimplicialComplex

**COORDINATES**: common::MatrixCoordinates for the vertices of the simplicial complex, such that the complex is embedded without crossings in some R

^{e}. Vector (x_{1}, .... x_{e}) represents a point in Euclidean e-space.**N_UNIMODULAR**: common::Intcount how many simplcies of a geometric simplicial complex are unimodular.

**SIGNATURE**: common::IntSignature of a geometric simplicial complex embedded in the integer lattice. Like DUAL_GRAPH_SIGNATURE, but only simplices with odd normalized volume are counted.

**UNIMODULAR**: common::BoolA geometric simplicial complex is unimodular if all simplices have unit normalized volume.

An abstract simplicial complex represented by its facets.

#### Properties of SimplicialComplex

These properties capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice.

**BOUNDARY**: SimplicialComplexCodimension-1-faces of a PSEUDO_MANIFOLD which are contained in one facet only.

**DIM**: common::IntMaximal dimension of the FACETS, where the dimension of a facet is defined as the number of its vertices minus one.

**DUAL_GRAPH**: graph::Graph<Undirected>The graph of facet neighborhood. Two FACETS are neighbors if they share a (d-1)-dimensional face.

#### Properties of DUAL_GRAPH

**F2_VECTOR**: common::Matrix<Int, NonSymmetric>f

_{ik}is the number of incident pairs of i-faces and k-faces; the main diagonal contains the F_VECTOR.**FACETS**: common::Array<Set<Int>>Faces which are maximal with respect to inclusion, encoded as their ordered set of vertices. The vertices must be numbered 0, ..., n-1.

**F_VECTOR**: common::Array<Int>f

_{k}is the number of k-faces, for k = 0,... , d, where d is the dimension.**HASSE_DIAGRAM**: graph::FaceLatticeThe face lattice of the simplical complex organized as a directed graph. Each node corresponds to some face of the simplical complex. It is represented as the list of vertices comprising the face. The outgoing arcs point to the containing faces of the next dimension. An artificial top node is added to represent the entire complex.

#### Properties of HASSE_DIAGRAM

**MORSE_MATCHING_CRITICAL_FACES**: common::Array<Set<Int>>The critical faces of the computed Morse matching, i.e., the faces not incident to any reoriented arc (not matched). FIXME: temporary

**MORSE_MATCHING_CRITICAL_FACE_VECTOR**: common::Array<Int>The vector of critical faces in each dimension. FIXME: temporary

**MORSE_MATCHING_N_CRITICAL_FACES**: common::IntNumber of critical faces of the computed Morse matching. FIXME: temporary

**MINIMAL_NON_FACES**: common::Array<Set<Int>>Inclusion minimal non-faces (vertex subsets which are not faces of the simplicial complex).

**ODD_SUBCOMPLEX**: SimplicialComplexSubcomplex generated by faces of codimension 2 that are contained in an odd number of faces of codimension 1.

**PROJ_DICTIONARY**: common::Array<Int>For each vertex the corresponding vertex of facet 0 with respect to the action of the group of projectivities.

**PROJ_ORBITS**: common::PowerSet<Int>Orbit decomposition of the group of projectivities acting on the set of vertices of facet 0.

**VERTEX_INDICES**: common::Array<Int>Indices of the vertices from INPUT_FACES. That is, the map i \mapsto v_i.

These properties are for input only. They allow redundant information.

**INPUT_FACES**: common::Array<Set<Int>>Any description of the faces of a simplicial complex with vertices v_0 < v_1 < v_2 < ... arbitrary. Redundant faces allowed.

The following properties are topological invariants.

**BALL**: common::BoolDetermines if this is homeomorphic to a ball. In general, this is undecidable; therefore, the implementation depends on heuristics. May be true or false or undef (if heuristic does not succeed).

**CLOSED_PSEUDO_MANIFOLD**: common::BoolTrue if this is a PURE simplicial complex with the property that each ridge is contained in exactly two facets.

**COCYCLES**: common::Array<CycleGroup<Integer>>Representatives of cocycle groups, listed in increasing codimension order. See CycleGroup for explanation of encoding of each group.

**COHOMOLOGY**: common::Array<HomologyGroup<Integer>>Reduced cohomology groups, listed in increasing codimension order. See HomologyGroup for explanation of encoding of each group.

**CYCLES**: common::Array<CycleGroup<Integer>>Representatives of cycle groups, listed in increasing dimension order. See CycleGroup for explanation of encoding of each group.

**EULER_CHARACTERISTIC**: common::IntReduced Euler characteristic. Alternating sum of the F_VECTOR minus 1.

**FUNDAMENTAL_GROUP**: common::Pair<Int, List<List<Pair<Int, Int>>>>A finite representation of the fundamental group. The fundamental group is represented as a pair of an integer, the number of generators, and a list of relations. The generators are numbered consecutively starting with zero. A relation is encoded as a list of pairs, each pair consisting of a generator and its exponent.

You may use the fundamental2gap method to produce a

`GAP`

file.**FUNDAMENTAL_GROUP_GEN_LABELS**: common::Array<String>Labels of the generators of the FUNDAMENTAL_GROUP. The labels can be chosen freely. If the FUNDAMENTAL_GROUP is computed by polymake, the generators correspond to the edges of the complex. Hence they are labeled

`g`

followed by the vertices of the edge, e.g.`g3_6`

corresponds to the edge {3 6}.**HOMOLOGY**: common::Array<HomologyGroup<Integer>>Reduced simplicial homology groups H

_{0}, ..., H_{d}(integer coefficients), listed in increasing dimension order. See HomologyGroup for explanation of encoding of each group.**INTERSECTION_FORM**: IntersectionFormParity and signature of the intersection form of a closed oriented 4-manifold.

**KNOT**: common::Array<Set<Int>>Edge-subset of a 3-sphere which is a knot or link, that is, a collection of pairwise disjoint cycles.

**MANIFOLD**: common::BoolDetermines if this is a compact simplicial manifold with boundary. Depends on heuristic SPHERE recognition. May be true or false or undef (if heuristic does not succeed).

**ORIENTATION**: common::Array<Bool>An orientation of the facets of an ORIENTED_PSEUDO_MANIFOLD, such that the induced orientations of a common ridge of two neighboring facets cancel each other out. Each facet is marked with

*true*if the orientation is given by the increasing vertex ordering and is marked with*false*if the orientation is obtained from the increasing vertex ordering by a transposition.**ORIENTED_PSEUDO_MANIFOLD**: common::BoolTrue if this is a PSEUDO_MANIFOLD with top level homology isomorphic to Z.

**PSEUDO_MANIFOLD**: common::BoolTrue if this is a PURE simplicial complex with the property that each ridge is contained in either one or two facets.

**SPHERE**: common::BoolDetermines if this is homeomorphic to a sphere. In general, this is undecidable; therefore, the implementation depends on heuristics. May be true or false or undef (if heuristic does not succeed).

**STIEFEL_WHITNEY**: common::Array<PowerSet<Int>>Mod 2 cycle representation of Stiefel-Whitney classes. Each cycle is represented as a set of simplices.

These properties are for visualization.

**MIXED_GRAPH**: graph::EdgeWeightedGraphThe nodes of the mixed graph are the nodes of the primal GRAPH and the DUAL_GRAPH. Additional to the primal and dual edges, there is an edge between a primal and a dual node iff the primal node represents a vertex of the corresponding facet of the dual node.

**FIXME:**temporary

#### User Methods of SimplicialComplex

These methods capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice.

**CONNECTED_COMPONENTS**() → PowerSet<Int>**CONNECTIVITY**() → Int**DUAL_BIPARTITE**() → Bool**DUAL_CONNECTED_COMPONENTS**() → PowerSet<Int>**DUAL_CONNECTIVITY**() → PowerSet<Int>**DUAL_GRAPH_SIGNATURE**() → Int**DUAL_MAX_CLIQUES**() → PowerSet<Int>**GRAPH_SIGNATURE**() → Int**labeled_vertices**(label ...) → Set<Int>**MAX_CLIQUES**() → PowerSet<Int>**VERTEX_DEGREES**() → Array<Int>

The following methods compute topological invariants.

**DUAL_CONNECTED**() → Bool**fundamental2gap**(filename)Writes the FUNDAMENTAL_GROUP using FUNDAMENTAL_GROUP_GEN_LABELS to the given file in GAP input format.

##### Parameters

String filename **N_CONNECTED_COMPONENTS**() → Int

These methods are for visualization.

**VISUAL**() → Visual::SimplicialComplexVisualizes the complex.

If G_DIM < 4, the GRAPH and the facets are visualized using the COORDINATES.

Otherwise, the spring embedder and the GRAPH are used to produce coordinates for the visualization.

If JavaView is used to visualize the complex, all faces of one facet build a geometry in the jvx-file, so you may use

*Method -> Effect -> Explode Group of Geometries*in the JavaView menu.##### Options

Bool mixed_graph use the MIXED_GRAPH for the spring embedderInt seed random seed value for the string embedderoption list: Visual::Polygon::decorations option list: Visual::Graph::decorations ##### Returns

Visual::SimplicialComplex **VISUAL_DUAL_GRAPH**() → Visual::SimplicialComplexUses the spring embedder to visualize the DUAL_GRAPH.

##### Options

Int seed random seed value for the string embedderoption list: Visual::Graph::decorations ##### Returns

Visual::SimplicialComplex **VISUAL_FACE_LATTICE**() → Visual::SimplicialComplexLatticeVisualize the HASSE_DIAGRAM of a simplicial complex as a multi-layer graph.

##### Options

Int seed random seed value for the node placementoption list: Visual::Lattice::decorations ##### Returns

Visual::SimplicialComplexLattice **VISUAL_GRAPH**() → Visual::SimplicialComplexUses the spring embedder to visualize the GRAPH.

##### Options

Int seed random seed value for the string embedderoption list: Visual::Graph::decorations ##### Returns

Visual::SimplicialComplex **VISUAL_MIXED_GRAPH**()Uses the spring embedder to visualize the MIXED_GRAPH.

##### Options

Int seed random seed value for the string embedderoption list: Visual::Graph::decorations

#### Permutations of SimplicialComplex

**FacetPerm**UNDOCUMENTED

#### Properties of FacetPerm

**VertexPerm**UNDOCUMENTED

#### Properties of VertexPerm

Visualization of the simplicial complex.

#### User Methods of Visual::SimplicialComplex

**MORSE_MATCHING**()Add the MORSE_MATCHING to the visualization of the SimplicialComplex.

##### Options

option list: Visual::Graph::decorations **SUBCOMPLEX**(PROPERTY_NAME)Add a subcomplex with optional different graphical attributes.

##### Parameters

String PROPERTY_NAME or [ Facets ]##### Options

option list: Visual::Polygon::decorations option list: Visual::Graph::decorations option list: Visual::PointSet::decorations

Visualization of the HASSE_DIAGRAM of a simplicial complex as a multi-layer graph.

#### User Methods of Visual::SimplicialComplexLattice

**FACES**(faces)Add distinguished faces with different graphical attributes

*NodeColor*and*NodeStyle*.##### Parameters

Array<Set> faces (to be changed in the near future)##### Options

option list: Visual::Lattice::decorations **SUBCOMPLEX**(property)Add a subcomplex with different graphical attributes.

##### Parameters

String property name of the subcomplex property (to be changed in the near future)##### Options

option list: Visual::Lattice::decorations

## User Functions

These functions compare two SimplicialComplex

**find_facet_vertex_permutations**(complex1, complex2) → Pair<Array<Int>, Array<int>>Find the permutations of facets and vertices which maps the first complex to the second one. The facet permutation is the first component of the return value. If the complexes are not isomorphic, an exception is thrown.

**Example:**- To print the vertex permutation that maps the 3-simplex to its mirror image, type this:
`> $p = find_facet_vertex_permutations(simplex(3),scale(simplex(3),-1));`

`> print $p->first;`

`3 2 1 0`

**isomorphic**(complex1, complex2) → BoolDetermine whether two given complexes are combinatorially isomorphic. The problem is reduced to graph isomorphism of the vertex-facet incidence graphs.

**pl_homeomorphic**(complex1, complex2) → BoolTries to determine whether two complexes are pl-homeomorphic by using bistellar flips and a simulated annealing strategy.

You may specify the maximal number of

*rounds*, how often the system may*relax*before heating up and how much*heat*should be applied. The function stops computing, once the size of the triangulation has not decreased for*rounds*iterations. If the*abs*flag is set, the function stops after*rounds*iterations regardless of when the last improvement took place. Additionally, you may set the threshold*min_n_facets*for the number of facets when the simplification ought to stop. Default is d+2 in the CLOSED_PSEUDO_MANIFOLD case and 1 otherwise.If you want to influence the distribution of the dimension of the moves when warming up you may do so by specifying a

*distribution*. The number of values in*distribution*determines the dimensions used for heating up. The heating and relaxing parameters decrease dynamically unless the*constant*flag is set. The function prohibits to execute the reversed move of a move directly after the move itself unless the*allow_rev_move*flag is set. Setting the*allow_rev_move*flag might help solve a particular resilient problem.If you are interested in how the process is coming along, try the

*verbose*option. It specifies after how many rounds the current best result is displayed.The

*obj*determines the objective function used for the optimization. If*obj*is set to 0, the function searches for the triangulation with the lexicographically smallest f-vector, if*obj*is set to 1, the function searches for the triangulation with the reversed-lexicographically smallest f-vector and if*obj*is set to 2 the sum of the f-vector entries is used. The default is 1.##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 ##### Options

Int rounds Bool abs Int obj Int relax Int heat Bool constant Bool allow_rev_move Int min_n_facets Int verbose Int seed Bool quiet Array<Int> distribution ##### Returns

Bool

Special purpose functions.

**is_generalized_shelling**(FaceList) → BoolCheck if a given sequence of faces of a simplicial complex is a generalized shelling.

**is_vertex_decomposition**(complex, vertices) → BoolCheck whether a given ordered subset of the vertex set is a

*vertex decomposition*. Works for 1-, 2- and 3-manifolds only!**mixed_graph**(complex)**morse_matching**(complex) → EdgeMapCompute a Morse matching. Two heuristics are implemented:

(1) A simple greedy algorithm:The arcs are visited in lexicographical order, i.e.:we proceed by levels from top to bottom,visit the faces in each dimension in lexicographical order,and visited the faces covered by these faces in lexicographical order.This heuristic is used by default and with heuristic => 1.(2) A Morse matching can be improved by canceling critical cellsalong unique alternating paths, see functionprocessAlternatingPaths() in file morse_matching_tools.h .This idea is due to Robin Forman:Morse Theory for Cell-Complexes,Advances in Math., 134 (1998), pp. 90-145.This heuristic is used by default and with heuristic => 2.The default setting is to use both, i.e., to run the greedy algorithm and then improve the result by the canceling algorithm.

Morse matchings for the bottom level can be found optimally by spanning tree techniques. This can be enabled by the option levels => 1. If the complex is a pseudo-manifold the same can be done for the top level (option levels => 2). By specifying option levels => 0, both levels can be computed by spanning trees. For 2-dim pseudo-manifolds this computes an optimal Morse matching.

##### Parameters

SimplicialComplex complex given by its Hasse diagram##### Options

Int heuristic (1=greedy, 2=cancel, 0=both (default))Int levels (1=bottom, 2=top, 0=both (default))##### Returns

EdgeMap matching a labelling of the edges of the Hasse diagram with integer values, where 1 means that the edge is in the matching**morse_matching_size**(complex) → IntCompute the number of edges in a Morse matching.

##### Parameters

SimplicialComplex complex a complex with a Morse matching##### Returns

Int the number of edges in the matching.**poset_by_inclusion**(P) → Graph<Directed>Construct the inclusion poset from a given container. The elements of the container are interpreted as sets. They define a poset by inclusion. The function returns this poset encoded as a directed graph. The direction is towards to larger sets. All relations are encoded, not only the covering relations. For details see Assarf, Joswig & Pfeifle: Webs of stars or how to triangulate sums of polytopes, to appear

**random_discrete_morse**(complex) → Map< Array<Int>, Int >Implementation of random discrete Morse algorithms by Lutz and Benedetti Returns a map of the number of occurrences of different reduction results indexed by the corresponding discrete Morse vectors (containing the number of critical cells per dimension)

##### Parameters

SimplicialComplex complex ##### Options

Int rounds Run for*r*roundsInt seed Set seed number for random number generatorInt strategy Set*strategy*=>0 (default) for random-random: uniformly random selecting of a face to collapse or as critical face Set*strategy*=>1 for random-lex-first: uniformly random relabeling of vertices, then selecting lexicographically first face for collapse or as a critical face Set*strategy*=>2 for random-lex-last: uniformly random relabeling of vertices, then selecting lexicographically last face for collapse or as a critical faceInt verbose *v*Prints message after running every*v*roundsArray<Int> try_until_reached Used together with*rounds*=>r; When*try_until_reached*=>[a,...,b], runs for*r*rounds or until [a,...,b] is foundArray<Int> try_until_exception Used together with*rounds*=>r; When*try_until_exception*=>[a,...,b], runs for*r*rounds or until anything other than [a,...,b] is foundString save_collapsed Save all facets that remain after initial collapse to an XML file of a Simplicial Complex. Rounds that have Morse vector [1,0,...,0] or [1,0,...,0,1] will save nothing. Filename must have quotation marks:*save_collapsed*=>"path/to/filename". The XML files are saved as "path/to/filename_currentround.top".##### Returns

Map< Array<Int>, Int > **stabbing_order**(P) → graph::Graph<Directed>Determine the stabbing partial order of a simplicial ball with respect to the origin. The origin may be a vertex or not. For details see Assarf, Joswig & Pfeifle: Webs of stars or how to triangulate sums of polytopes, to appear

**stanley_reisner**(complex) → ideal::IdealCreates the

*Stanley-Reisner ideal*of a simplicial complex. Optional*ring*parameter is required to have precisely as many variables as*C*has vertices.**star_of_zero**(C) → Set<Set<Int>>Find the facets of the star of the origin in the simplicial complex. The origin may be a vertex or not. For details see Assarf, Joswig & Pfeifle: Webs of stars or how to triangulate sums of polytopes, to appear

**star_shaped_balls**(P) → Array<Set<Set>>Enumerate all balls formed by the simplices of a geometric simplicial complex that are strictly star-shaped with respect to the origin. The origin may be a vertex or not. For details see Assarf, Joswig & Pfeifle: Webs of stars or how to triangulate sums of polytopes, to appear

**stiefel_whitney**(facets) → Array<PowerSet<Int>>Computes

*Stiefel-Whitney classes*of mod 2 Euler space (in particular, closed manifold). Use option*verbose*to show regular pairs and cycles. A narrower dimension range of interest can be specified. Negative values are treated as co-dimension - 1##### Parameters

Array<Set<Int>> facets the facets of the simplicial complex##### Options

Int high_dim Int low_dim Bool verbose ##### Returns

Array<PowerSet<Int>>

These functions construct a new SimplicialComplex from other objects of the same type.

**alexander_dual**(complex) → SimplicialComplexComputes the Alexander dual complex, that is, the complements of all non-faces. The vertex labels are preserved unless the

*nol*flag is specified.**barycentric_subdivision**(complex) → SimplicialComplexComputes the

*barycentric subdivision*of*complex*.##### Parameters

SimplicialComplex complex ##### Options

String pin_hasse_section default: HASSE_DIAGRAMString label_section default: VERTEX_LABELSString coord_section default: VERTICESBool geometric_realization set to 1 to obtain a GeometricSimplicialComplex, default: 0##### Returns

SimplicialComplex **bistellar_simplification**(complex) → SimplicialComplexHeuristic for simplifying the triangulation of the given manifold without changing its PL-type. The function uses bistellar flips and a simulated annealing strategy.

You may specify the maximal number of

*rounds*, how often the system may*relax*before heating up and how much*heat*should be applied. The function stops computing, once the size of the triangulation has not decreased for*rounds*iterations. If the*abs*flag is set, the function stops after*rounds*iterations regardless of when the last improvement took place. Additionally, you may set the threshold*min_n_facets*for the number of facets when the simplification ought to stop. Default is d+2 in the CLOSED_PSEUDO_MANIFOLD case and 1 otherwise.If you want to influence the distribution of the dimension of the moves when warming up you may do so by specifying a

*distribution*. The number of values in*distribution*determines the dimensions used for heating up. The heating and relaxing parameters decrease dynamically unless the*constant*flag is set. The function prohibits to execute the reversed move of a move directly after the move itself unless the*allow_rev_move*flag is set. Setting the*allow_rev_move*flag might help solve a particular resilient problem.If you are interested in how the process is coming along, try the

*verbose*option. It specifies after how many rounds the current best result is displayed.The

*obj*determines the objective function used for the optimization. If*obj*is set to 0, the function searches for the triangulation with the lexicographically smallest f-vector, if*obj*is set to any other value the sum of the f-vector entries is used. The default is 1.##### Parameters

SimplicialComplex complex ##### Options

Int rounds Bool abs Int obj Int relax Int heat Bool constant Bool allow_rev_move Int min_n_facets Int verbose Int seed Bool quiet Array<Int> distribution ##### Returns

SimplicialComplex **bs2quotient**(P, complex) → SimplicialComplexCreate a simplicial complex from a simplicial subdivision of a given complex by identifying vertices on the boundary of the original complex according to a group that acts on vertices.

Contained in extension`bundled:group`

.##### Parameters

polytope::Polytope P the underlying polytopeSimplicialComplex complex a sufficiently fine subdivision of P, for example the second barycentric subdivision##### Returns

SimplicialComplex **colored_ball_from_colored_sphere**(complex) → SimplicialComplexExtends the triangulation and coloring of a k-colored (d-1)-sphere to a max{k,d+1}-colored triangulation of a d-ball. The colors are integer numbers.

The old vertex labels are preserved unless the

*no_labels*flag is specified. The new vertices get labeled`new_i`

(i=0, 1, 2, ...). If a new label is not unique,`_j`

is added for the smallest integer j which makes the label unique.Contained in extension`bundled:local`

.**cone**(complex, k) → SimplicialComplexProduce the

*k*-cone over a given simplicial complex.##### Parameters

SimplicialComplex complex Int k default is 1##### Options

Array<String> apex_labels labels of the apex vertices. Default labels have the form`apex_0, apex_1, ...`

. In the case the input complex has already vertex labels of this kind, the duplicates are avoided.Bool nol don't generate any vertex labels.##### Returns

SimplicialComplex **connected_sum**(complex1, complex2, f1, f2) → SimplicialComplexCompute the

*connected sum*of two complexes.Parameters

*f_1 and*f_2// specify which facet of the first and second complex correspondingly are glued together. Default is the 0-th facet of both.The vertices in the selected facets are identified with each other according to their order in the facet (that is, in icreasing index order). The option

*permutation*allows to get an alternative identification. It should specify a permutation of the vertices of the second facet.The vertices of the new complex get the original labels with

`_1`

or`_2`

appended, according to the input complex they came from. If you set the*no_labels*flag, the label generation will be omitted.##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 Int f1 default: 0Int f2 default: 0##### Options

Array<Int> permutation Bool no_lables ##### Returns

SimplicialComplex **covering_relations**(P) → Graph<Directed>**deletion**(complex, face) → SimplicialComplexRemove the given

*face*and all the faces containing it.##### Parameters

SimplicialComplex complex Set<Int> face specified by vertex indices. Please use labeled_vertices if you want to specify the face by vertex labels.##### Options

Bool no_labels do not write vertex labels.##### Returns

SimplicialComplex **disjoint_union**(complex1, complex2) → SimplicialComplexProduce the

*disjoint union*of the two given complexes.##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 ##### Options

Bool labels creates VERTEX_LABELS. The vertex labels are built from the original labels with a suffix`_1`

or`_2`

appended.##### Returns

SimplicialComplex **edge_contraction**(complex) → SimplicialComplexHeuristic for simplifying the triangulation of the given manifold without changing its PL-type. Choosing a random order of the vertices, the function tries to contract all incident edges.

**foldable_prism**(complex) → GeometricSimplicialComplexProduce a

*prism*over a given SimplicialComplex.##### Parameters

GeometricSimplicialComplex complex ##### Options

Bool geometric_realization ##### Returns

GeometricSimplicialComplex **hom_poset**(P, Q) → Graph<Directed>Construct the poset of order preserving maps from one poset to another

**hom_poset**(homs, Q) → Graph<Directed>Construct the poset of order preserving maps from one poset to another

**h_induced_quotient**(C, vertices) → SimplicialComplexLet

*C*be the given simplicial and A the subcomplex induced by the given*vertices*. Then this function produces a simplicial complex homotopy equivalent to*C*mod A by adding the cone over A with apex a to*C*. The label of the apex my be specified via the option*apex*.##### Parameters

SimplicialComplex C Set<Int> vertices ##### Options

Bool no_labels tells the client not to write any labels.String apex ##### Returns

SimplicialComplex **induced_subcomplex**(complex, vertices) → SimplicialComplexProduce the subcomplex consisting of all faces which are contained in the given set of

*vertices*.##### Parameters

SimplicialComplex complex Set<Int> vertices ##### Options

Bool no_label tells the client not to create any labels.Bool geom_real tells the client to inherit the COORDINATES.##### Returns

SimplicialComplex **iterated_barycentric_subdivision**(complex, k) → SimplicialComplexComputes the

*k*-th*barycentric subdivision*of*complex*by iteratively calling barycentric_subdivision.##### Parameters

SimplicialComplex complex Int k ##### Options

String pin_hasse_section default: HASSE_DIAGRAMString label_section default: VERTEX_LABELSString coord_section default: VERTICESBool geometric_realization set to 1 to obtain a GeometricSimplicialComplex, default: 0##### Returns

SimplicialComplex **join_complexes**(complex1, complex2) → SimplicialComplexCreates the join of

*complex1*and*complex2*.##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 ##### Options

Bool labels creates VERTEX_LABELS. The vertex labels are built from the original labels with a suffix`_1`

or`_2`

appended.##### Returns

SimplicialComplex **k_skeleton**(complex, k) → SimplicialComplexProduce the

*k*-skeleton.##### Parameters

SimplicialComplex complex Int k ##### Options

Bool vertex_labels whether to create VERTEX_LABELS##### Returns

SimplicialComplex **k_skeleton**(complex, k) → GeometricSimplicialComplexProduce the

*k*-skeleton.##### Parameters

GeometricSimplicialComplex complex Int k ##### Options

Bool vertex_labels whether to create VERTEX_LABELS##### Returns

GeometricSimplicialComplex **link_complex**(complex, face) → SimplicialComplexProduce the

*link*of a*face*of the*complex*##### Parameters

SimplicialComplex complex Set<int> face ##### Options

Bool no_labels tells the client not to create any labels.##### Returns

SimplicialComplex **poset_homomorphisms**(P, Q) → Set<Array<Int>>Enumerate all order preserving maps from one poset to another

##### Parameters

Graph<Directed> P Graph<Directed> Q ##### Options

Array<Int> prescribed_map A vector of length P.nodes() with those images in Q that should be fixed. Negative entries will be enumerated over.##### Returns

Set<Array<Int>> **simplicial_product**(complex1, complex2) → SimplicialComplexComputes the

*simplicial product*of two complexes. Vertex orderings may be given as options.##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 ##### Options

Array<Int> vertex_order1 Array<Int> vertex_order2 Bool geometric_realization default 0Bool color_cons Bool no_labels ##### Returns

SimplicialComplex **simplicial_product**<Scalar> (complex1, complex2) → GeometricSimplicialComplex<Scalar>Computes the

*simplicial product*of two complexes. Vertex orderings may be given as options.##### Type Parameters

Scalar ##### Parameters

GeometricSimplicialComplex complex1 GeometricSimplicialComplex complex2 ##### Options

Array<Int> vertex_order1 Array<Int> vertex_order2 Bool geometric_realization default 1Bool color_cons Bool no_labels ##### Returns

GeometricSimplicialComplex<Scalar> **star**(complex, face) → SimplicialComplexProduce the

*star*of the*face*of the*complex*.##### Parameters

SimplicialComplex complex Set<int> face ##### Options

Bool labels creates VERTEX_LABELS.##### Returns

SimplicialComplex **star_deletion**(complex, face) → SimplicialComplexRemove the star of a given

*face*.##### Parameters

SimplicialComplex complex Set<Int> face specified by vertex indices. Please use labeled_vertices if you want to specify the face by vertex labels.##### Options

Bool no_labels do not write vertex labels.##### Returns

SimplicialComplex **stellar_subdivision**(complex, faces) → SimplicialComplexComputes the complex obtained by stellar subdivision of the given

*faces*of the*complex*.##### Parameters

SimplicialComplex complex Array<Set<Int>> faces ##### Options

Bool no_labels Bool geometric_realization default 0##### Returns

SimplicialComplex **stellar_subdivision**(complex, face) → SimplicialComplexComputes the complex obtained by stellar subdivision of the given

*face*of the*complex*.##### Parameters

SimplicialComplex complex Set<Int> face ##### Options

Bool no_labels Bool geometric_realization default 0##### Returns

SimplicialComplex **sum_triangulation**(P, Q, WebOfStars) → GeometricSimplicialComplexProduce a specific sum-triangulation of two given triangulations. and a WebOfStars. There are P-sum-triangulations and Q-sum-triangulations. If the image of the star of the origin of P is empty then we have a Q-sum-triangulation; otherwise it is a P-sum-triangulation. For details see Assarf, Joswig & Pfeifle: Webs of stars or how to triangulate sums of polytopes, to appear

##### Parameters

GeometricSimplicialComplex P first complexGeometricSimplicialComplex Q second complexIncidenceMatrix WebOfStars Every row corresponds to a full dimensional simplex in P and every column to a full dimensional simplex in Q.##### Options

Bool origin_first decides if the origin should be the first point in the resulting complex. Default=0##### Returns

GeometricSimplicialComplex **suspension**(complex, k) → SimplicialComplexProduce the

over a given simplicial complex.*k*-suspension##### Parameters

SimplicialComplex complex Int k default value is 1##### Options

Array<String> labels for the apices. By default apices are labeled with`apex_0+`

,`apex_0-`

,`apex_1+`

, etc. If one of the specified labels already exists, a unique one is made by appending`_i`

where*i*is some small number.Bool nol do not produce any labels.##### Returns

SimplicialComplex **triang_neighborhood**(complex, width)Create a triangulated tubular neighborhood of a pure 2-complex. If the complex is a link with the property that each vertex and its two neighbours are in general position after projection to the x,y-plane, then one might specify a rational number

*width*to tell the client to compute COORDINATES of the triangulated tubular neighborhood. If the*width*/ is chosen too large, the computed realization will be self intersecting. If each connected component of the link has an even number of facets, then the following holds: An edge of the resulting complex is contained in an odd number of facets iff it corresponds to one of the edges of the link.Contained in extension`bundled:local`

.##### Parameters

SimplicialComplex complex Rational width default: 0**union**(complex1, complex2) → SimplicialComplexProduce the union of the two given complexes, identifying vertices with equal labels.

##### Parameters

SimplicialComplex complex1 SimplicialComplex complex2 ##### Options

Bool labels creates VERTEX_LABELS.##### Returns

SimplicialComplex **web_of_stars**(poset_hom, star_shaped_balls, triang) → IncidenceMatrixProduce a web of stars from two given triangulations and a map between them.

##### Parameters

Array<Int> poset_hom the poset homomorphism from stabbing order to star-shaped ballsArray<Set<Set<Int>>> star_shaped_balls the collection of star-shaped balls of TArray<Set<Int>> triang the facets of the underlying triangulation of Q##### Returns

IncidenceMatrix WebOfStars Every row corresponds to a full dimensional simplex in P and every column to a full dimensional simplex in Q.

These functions construct a new SimplicialComplex from other objects.

**clique_complex**(graph) → SimplicialComplexProduce the

*clique complex*of a given graph. If*no_labels*is set to 1, the labels are not copied.**independence_complex**(matroid) → SimplicialComplexProduce the

*independence complex*of a given matroid. If*no_labels*is set to 1, the labels are not copied.

With these clients you can create special examples of simplicial complexes and complexes belonging to parameterized families.

**ball**(d) → GeometricSimplicialComplexA

*d*-dimensional*ball*, realized as the*d*-simplex.**complex_projective_plane**() → SimplicialComplexThe complex projective plane with the vertex-minimal triangulation by Kühnel and Brehm.

##### Returns

SimplicialComplex **cube_complex**()Produces a triangulated pile of hypercubes: Each cube is split into d! tetrahedra, and the tetrahedra are all grouped around one of the diagonal axes of the cube. DOC_FIXME args: x_1, ... , x_d

**klein_bottle**() → SimplicialComplex**rand_knot**(n_edges) → SimplicialComplexProduce a random knot (or link) as a polygonal closed curve in 3-space. The knot (or each connected component of the link) has

*n_edges*edges.The vertices are uniformly distributed in [-1,1]

^{3}, unless the*on_sphere*option is set. In the latter case the vertices are uniformly distributed on the 3-sphere. Alternatively the*brownian*option produces a knot by connecting the ends of a simulated brownian motion.**real_projective_plane**() → SimplicialComplexThe real projective plane with its unique minimal triangulation on six vertices.

##### Returns

SimplicialComplex **simplex**(d) → SimplicialComplex**sphere**(d) → GeometricSimplicialComplexThe

*d*-dimensional*sphere*, realized as the boundary of the (*d*+1)-simplex.**surface**(g) → SimplicialComplexProduce a

*surface of genus*. For*g**g*>= 0 the client produces an orientable surface, otherwise it produces a non-orientable one.**torus**() → SimplicialComplexThe Császár Torus. Geometric realization by Frank Lutz, Electronic Geometry Model No. 2001.02.069

##### Returns

SimplicialComplex **unknot**(m, n) → GeometricSimplicialComplexProduces a triangulated 3-sphere with the particularly NASTY embedding of the unknot in its 1-skeleton. The parameters

*m*>= 2 and*n*>= 1 determine how entangled the unknot is.*eps*determines the COORDINATES.

Functions producing big objects which are not contained in application topaz.

The following functions compute topological invariants.

**cap_product**(complex)Compute and print all cap products of cohomology and homology cycles.

##### Parameters

SimplicialComplex complex **homology**(complex, co)Calculate the

*(co-)homology groups*of a simplicial complex.##### Parameters

Array<Set<int>> complex Bool co set to true for*co*homology##### Options

Int dim_low narrows the dimension range of interest, with negative values being treated as co-dimensionsInt dim_high see*dim_low***homology_and_cycles**(complex, co)Calculate the

*(co-)homology groups*and*cycle representatives*of a simplicial complex.##### Parameters

Array<Set<int>> complex Bool co set to true for*co*homology##### Options

Int dim_low narrows the dimension range of interest, with negative values being treated as co-dimensionsInt dim_high see*dim_low*

## Property Types

The following property_types are topological invariants.

**CycleGroup**<Scalar>A group is encoded as a pair of an integer matrix and a vector of faces. The elements of the group can be obtained by symbolic multiplication of both.

Access methods:

*coeff*delivers the integer matrix,*faces*the vector of faces.##### Type Parameters

Scalar integer type of matrix elements**HomologyGroup**A group is encoded as a sequence ( { (t

_{1}m_{1}) ... (t_{n}m_{n}) } f) of non-negative integers, with t_{1}> t_{2}> ... > t_{n}> 1, plus an extra non-negative integer f.The group is isomorphic to (Z/t

_{1})^{m1}× ... × (Z/t_{n})^{mn}× Z^{f}, where Z^{0}is the trivial group.Access methods:

*torsion*delivers the list of Z-groups,*betti_number*the number f.**IntersectionForm**TODO: explain the meaning of the fields: parity, positive, negative