| Both sides previous revision Previous revision Next revision | Previous revisionLast revisionBoth sides next revision |
| playground:playground [2019/03/03 18:17] – oroehrig | playground:playground [2019/03/25 20:59] – oroehrig |
|---|
| | ====== 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 ([[playground/playground/SimplicialComplex#MANIFOLD |manifold recognition]],\\ [[playground/playground/SimplicialComplex#HOMOLOGY |homology groups]], etc.), explore the local vertex environment ([[playground/playground#star |stars]], [[playground/playground#link |links]], etc.), and make a lot\\ of constructions.\\ The visualization means are constrained, as they are mostly based on the ''[[playground/playground/SimplicialComplex#GRAPH |GRAPH]]'' (1-skeleton) of a complex. |
| | imports from: |
| | * [[graph|application graph]] |
| | * [[common|application common]] |
| | uses: |
| | * [[ideal|application ideal]] |
| | * [[group|application group]] |
| | ===== Objects ===== |
| | * [[topaz:GeometricSimplicialComplex|GeometricSimplicialComplex]]:\\ A geometric simplicial complex, i.e., a simplicial complex with a geometric realization. //Scalar// is the numeric data type used for the coordinates. |
| | * [[topaz:HyperbolicSurface|HyperbolicSurface]]:\\ A hyperbolic surface (noncompact, finite area) is given by a triangulation [[/topaz/objects/HyperbolicSurface/properties/DCEL_DATA]] (the topological data) and [[/topaz/objects/HyperbolicSurface/properties/PENNER_COORDINATES]] (the metric data). |
| | * [[topaz:MorseMatching|MorseMatching]]:\\ A Morse matching is a reorientation of the arcs in the Hasse diagram of a simplicial complex such that at most one arc incident to each face is reoriented (matching condition) and the resulting orientation is acyclic (acyclicity condition). Morse matchings capture the main structure of discrete Morse functions, see Robin Forman: Morse Theory for Cell-Complexes, Advances in Math., 134 (1998), pp. 90-145. This property is computed by one of two heuristics. The default heuristic is a simple greedy algorithm ([[/topaz/objects/SimplicialComplex|greedy]]). The alternative is to use a canceling algorithm due to Forman ([[/topaz/objects/SimplicialComplex|cancel]]) or both ([[/topaz/objects/SimplicialComplex|both]]) together. Note that the computation of a Morse matching of largest size is NP-hard. See Michael Joswig, Marc E. Pfetsch: Computing Optimal Morse Matchings SIAM J. Discrete Math., 2006, to appear |
| | * [[topaz:SimplicialComplex|SimplicialComplex]]:\\ An abstract simplicial complex represented by its facets. |
| | * [[topaz:Visual::SimplicialComplex|Visual::SimplicialComplex]]:\\ Visualization of the simplicial complex. |
| | * [[topaz:Visual::SimplicialComplexLattice|Visual::SimplicialComplexLattice]]:\\ Visualization of the [[/topaz/objects/SimplicialComplex/properties/Combinatorics/HASSE_DIAGRAM]] of a simplicial complex as a multi-layer graph. |
| | ===== Functions ===== |
| |
| ---- | ---- |
| ==== Input Properties ==== | ==== Combinatorics ==== |
| These properties are for input only. They allow redundant information. | These functions capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice. |
| | \\ |
| | {{anchor:n_poset_homomorphisms:}} **''n_poset_homomorphisms([[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> P, [[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> Q)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' ''P'' : |
| | * ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' ''Q'' : |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Count all order preserving maps from one poset to another.\\ They are in fact enumerated, but only the count is kept track of using constant memory. |
| |
| === EQUATIONS === | ---- |
| | Type: /common/property_types/Algebraic Types/Matrix | | ==== Comparing ==== |
| Equations that hold for all [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]] of the cone. | These functions compare two [[/topaz/objects/SimplicialComplex]] |
| All vectors in this section must be non-zero. | \\ |
| Input section only. Ask for [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]] if you want to see an irredundant description of the linear span. | {{anchor:isomorphic:}} **''isomorphic([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| | * Determine whether two given complexes are combinatorially isomorphic.\\ The problem is reduced to graph isomorphism of the vertex-facet incidence graphs. |
| |
| === INEQUALITIES === | \\ |
| Type: /common/property_types/Algebraic Types/Matrix\\ Inequalities giving rise to the cone; redundancies are allowed. | {{anchor:find_facet_vertex_permutations:}} **''find_facet_vertex_permutations([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| All vectors in this section must be non-zero. | * //Parameters:// |
| Dual to [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]]. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground#Pair |Pair]]<[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>,[[playground/playground#Array |Array]]<[[playground/playground#Int |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. |
| |
| Input section only. Ask for [[/polytope/objects/Cone/properties/Geometry/FACETS]] if you want to compute an H-representation from a V-representation. | \\ |
| | {{anchor:pl_homeomorphic:}} **''pl_homeomorphic([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| === INPUT_LINEALITY === | * //Parameters:// |
| Type: /common/property_types/Algebraic Types/Matrix\\ (Non-homogenous) vectors whose linear span defines a subset of the lineality space of the cone; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| redundancies are allowed. All vectors in the input must be non-zero. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| Dual to [[/polytope/objects/Cone/properties/Input property/EQUATIONS]]. | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| | * Tries 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 ''[[playground/playground/SimplicialComplex#CLOSED_PSEUDO_MANIFOLD |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. |
| Input section only. Ask for [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]] if | |
| you want to compute a V-representation from an H-representation. | |
| | |
| === INPUT_RAYS === | |
| Type: /common/property_types/Algebraic Types/Matrix\\ (Non-homogenous) vectors whose positive span form the cone; redundancies are allowed. | |
| Dual to [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]]. All vectors in the input must be non-zero. | |
| | |
| Input section only. Ask for [[/polytope/objects/Cone/properties/Geometry/RAYS]] if you want to compute a V-representation from an H-representation. | |
| |
| ---- | ---- |
| ==== Combinatorics ==== | ==== Other ==== |
| These properties capture combinatorial information of the object. | Special purpose functions. |
| Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice. | \\ |
| | {{anchor:poset_by_inclusion:}} **''poset_by_inclusion([[playground/playground#Array |Array]]<[[playground/playground#poset |poset]] P)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#poset |poset]]'' ''P'' : |
| | * //Returns:// ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |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 |
| |
| === F2_VECTOR === | \\ |
| Type: /common/property_types/Algebraic Types/Matrix\\ The vector counting the number of incidences between pairs of faces. | {{anchor:is_vertex_decomposition:}} **''is_vertex_decomposition([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> vertices)''** |
| `f<sub>ik</sub>` is the number of incident pairs of `(i+1)`-faces and `(k+1)`-faces. | * //Parameters:// |
| The main diagonal contains the [[/polytope/objects/Cone/properties/Combinatorics/F_VECTOR]]. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>'' ''vertices'' : shedding vertices |
| | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| | * Check whether a given ordered subset of the vertex set is a __vertex decomposition__.\\ Works for 1-, 2- and 3-manifolds only! |
| |
| === ESSENTIALLY_GENERIC === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ All intermediate polytopes (with respect to the given insertion order) in the beneath-and-beyond algorithm are simplicial. | {{anchor:stiefel_whitney:}} **''stiefel_whitney([[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>> facets)''** |
| We have the implications: [[/polytope/objects/Cone/properties/Geometry/RAYS]] in general position => ESSENTIALLY_GENERIC => [[/polytope/objects/Cone/properties/Combinatorics/SIMPLICIAL]] | * //Parameters:// |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>'' ''facets'' : the facets of the simplicial complex |
| | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#PowerSet |PowerSet]]<[[playground/playground#Int |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 |
| |
| === EXCESS_RAY_DEGREE === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Measures the deviation of the cone from being simple in terms of the [[/polytope/objects/Cone/properties/Combinatorics/GRAPH]]. | {{anchor:star_of_zero:}} **''star_of_zero([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] C)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''C'' : |
| | * //Returns:// ''[[playground/playground#Set |Set]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |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 |
| |
| === COCIRCUIT_EQUATIONS === | \\ |
| Type: /common/property_types/Algebraic Types/SparseMatrix\\ A matrix whose rows contain the cocircuit equations of P. The columns correspond to the [[/polytope/objects/Cone/properties/Combinatorics/MAX_INTERIOR_SIMPLICES]]. | {{anchor:mixed_graph:}} **''mixed_graph([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * Produces the mixed graph of a //complex//. |
| |
| === RAY_SIZES === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Number of incident facets for each ray. | {{anchor:star_shaped_balls:}} **''star_shaped_balls([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''P'' : |
| | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#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 |
| |
| === FLAG_VECTOR === | \\ |
| Type: /common/property_types/Algebraic Types/Vector\\ Condensed form of the flag vector, containing all entries indexed by sparse sets in {0, ..., [[/polytope/objects/Cone/properties/Combinatorics/COMBINATORIAL_DIM]]-1} | {{anchor:stabbing_order:}} **''stabbing_order([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P)''** |
| in the following order: | * //Parameters:// |
| (1, f<sub>0</sub>, f<sub>1</sub>, f<sub>2</sub>, f<sub>02</sub>, f<sub>3</sub>, f<sub>03</sub>, f<sub>13</sub>, f<sub>4</sub>, f<sub>04</sub>, f<sub>14</sub>, f<sub>24</sub>, f<sub>024</sub>, f<sub>5</sub>, ...). | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''P'' : |
| Use Dehn-Sommerville equations, via user function [[/polytope/objects/Cone/methods/Combinatorics/N_FLAGS]], to extend. | * //Returns:// ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |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 |
| |
| === FACET_SIZES === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Number of incident rays for each facet. | {{anchor:stanley_reisner:}} **''stanley_reisner([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/Ideal# |Ideal]]'' |
| | * Creates the __Stanley-Reisner ideal__ of a simplicial complex. |
| |
| === RAYS_IN_RIDGES === | \\ |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ Ray-ridge incidence matrix, with rows corresponding to ridges and columns | {{anchor:is_generalized_shelling:}} **''is_generalized_shelling([[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]> FaceList)''** |
| to rays. Rays and ridges are numbered from 0 to [[/polytope/objects/Cone/properties/Combinatorics/N_RAYS]]-1 rsp. | * //Parameters:// |
| [[/polytope/objects/Cone/properties/Geometry/N_RIDGES]]-1, according to their order in [[/polytope/objects/Cone/properties/Geometry/RAYS]] rsp. [[/polytope/objects/Symmetry/SymmetrizedCocircuitEquations/properties/RIDGES]]. | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]>'' ''FaceList'' : |
| | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| | * Check if a given sequence of faces of a simplicial complex is a generalized shelling. |
| |
| === SIMPLICIAL_CONE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the cone is simplicial. | {{anchor:persistent_homology:}} **''persistent_homology''** |
| |
| === SIMPLICIAL === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the facets of the cone are simplicial. | {{anchor:random_discrete_morse:}} **''random_discrete_morse([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground#Map |Map]]<[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>,[[playground/playground#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) |
| |
| === FOLDABLE_COCIRCUIT_EQUATIONS === | \\ |
| Type: /common/property_types/Algebraic Types/SparseMatrix\\ A matrix whose rows contain the foldable cocircuit equations of P. The columns correspond to 2 * [[/polytope/objects/Cone/properties/Combinatorics/MAX_INTERIOR_SIMPLICES]]. | {{anchor:vietoris_rips_filtration:}} **''vietoris_rips_filtration<Coeff>([[playground/playground#Matrix |Matrix]] D, [[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> deg, [[playground/playground#Float |Float]] step_size, [[playground/playground#Int |Int]] k)''** |
| col 0 = 0, col 1 = first simplex (black copy), col 2 = first simplex (white copy), col 3 = second simplex (black copy), ... | * //Template Parameters:// |
| | * ''Coeff'' : desired coefficient type of the filtration |
| | * //Parameters:// |
| | * ''[[playground/playground#Matrix |Matrix]]'' ''D'' : the "distance matrix" of the point set (can be upper triangular) |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>'' ''deg'' : the degrees of input points |
| | * ''[[playground/playground#Float |Float]]'' ''step_size'' : |
| | * ''[[playground/playground#Int |Int]]'' ''k'' : dimension of the resulting filtration |
| | * //Returns:// ''[[playground/playground#Filtration |Filtration]]<[[playground/playground#SparseMatrix |SparseMatrix]]<[[playground/playground#vietoris |vietoris]]'' |
| | * Constructs the k-skeleton of the Vietrois Rips filtration of a point set. The set is passed as its so-called "distance matrix", whose (i,j)-entry is the distance between point i and j. This matrix can e.g. be computed using the distance_matrix function. The other inputs are an integer array containing the degree of each point, the desired distance step size between frames, and the dimension up to which to compute the skeleton. Redundant points will appear as seperate vertices of the complex. Setting k to |S| will compute the entire VR-Complex for each frame. |
| |
| === GRAPH === | ---- |
| Type: /graph/objects/Combinatorics/Graph\\ Vertex-edge graph obtained by intersecting the cone with a transversal hyperplane. | ==== Producing a new simplicial complex from others ==== |
| | These functions construct a new [[/topaz/objects/SimplicialComplex]] from other objects of the same type. |
| | \\ |
| | {{anchor:star_deletion:}} **''star_deletion([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : specified by vertex indices.\\ Please use ''[[playground/playground/SimplicialComplex#labeled_vertices |labeled_vertices]]'' if you want to specify the face by vertex labels. |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Remove the star of a given //face//. |
| |
| === RAYS_IN_FACETS === | \\ |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ Ray-facet incidence matrix, with rows corresponding to facets and columns | {{anchor:bistellar_simplification:}} **''bistellar_simplification([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| to rays. Rays and facets are numbered from 0 to [[/polytope/objects/Cone/properties/Combinatorics/N_RAYS]]-1 rsp. | * //Parameters:// |
| [[/polytope/objects/Cone/properties/Geometry/N_FACETS]]-1, according to their order in [[/polytope/objects/Cone/properties/Geometry/RAYS]] rsp. [[/polytope/objects/Cone/properties/Geometry/FACETS]]. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Heuristic 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 ''[[playground/playground/SimplicialComplex#CLOSED_PSEUDO_MANIFOLD |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. |
| |
| === N_RAY_FACET_INC === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Number of pairs of incident vertices and facets. | {{anchor:simplicial_product:}} **''simplicial_product''** |
| |
| === INTERIOR_RIDGE_SIMPLICES === | \\ |
| Type: /common/property_types/Basic Types/Array\\ The (//d//-1)-dimensional simplices in the interior. | {{anchor:connected_sum:}} **''connected_sum([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2, [[playground/playground#Int |Int]] f1, [[playground/playground#Int |Int]] f2)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * ''[[playground/playground#Int |Int]]'' ''f1'' : default: 0 |
| | * ''[[playground/playground#Int |Int]]'' ''f2'' : default: 0 |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Compute 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 glueing facet iteself is not included in the connected sum.\\ 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. |
| | * //Example://\\ Glueing together two tori to make a genus 2 double torus, rotating the second one clockwise: \\ <code> > $cs = connected_sum(torus(),torus(),permutation=>[1,2,0]); |
| | > print $cs->SURFACE.','.$cs->GENUS; |
| | 1,2 |
| | </code> |
| |
| === HASSE_DIAGRAM === | \\ |
| Type: /polytope/objects/Cone/properties/Combinatorics/HASSE_DIAGRAM\\ The face lattice of the cone organized as a directed graph. | {{anchor:triang_neighborhood:}} **''triang_neighborhood([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Rational |Rational]] width)''** |
| Top and bottom nodes represent the whole cone and the empty face. | * //Parameters:// |
| Every other node corresponds to some proper face of the cone. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Rational |Rational]]'' ''width'' : default: 0 |
| | * Create a triangulated tubular neighborhood of a [[playground/playground/SimplicialComplex#PURE |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 ''[[playground/playground/GeometricSimplicialComplex#COORDINATES |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. |
| |
| === FACETS_THRU_RAYS === | \\ |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ Transposed to [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_FACETS]]. | {{anchor:hom_poset:}} **''hom_poset''** |
| Notice that this is a temporary property; it will not be stored in any file. | |
| |
| === SELF_DUAL === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the cone is self-dual. | {{anchor:covering_relations:}} **''covering_relations([[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> P)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' ''P'' : |
| | * //Returns:// ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' |
| | * Construct the covering relations of a poset |
| |
| === N_RAYS === | \\ |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Cone/properties/Geometry/RAYS]] | {{anchor:h_induced_quotient:}} **''h_induced_quotient([[playground/playground/SimplicialComplex# |SimplicialComplex]] C, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> vertices)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''C'' : |
| | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''vertices'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Let //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//. |
| |
| === DUAL_GRAPH === | \\ |
| Type: /graph/objects/Combinatorics/Graph\\ Facet-ridge graph. Dual to [[/polytope/objects/Cone/properties/Combinatorics/GRAPH]]. | {{anchor:sum_triangulation:}} **''sum_triangulation([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P, [[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] Q, [[playground/playground#IncidenceMatrix |IncidenceMatrix]] WebOfStars)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''P'' : first complex |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''Q'' : second complex |
| | * ''[[playground/playground#IncidenceMatrix |IncidenceMatrix]]'' ''WebOfStars'' : Every row corresponds to a full dimensional simplex in P and every column to a full dimensional simplex in Q. |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| | * Produce 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 |
| |
| === MAX_INTERIOR_SIMPLICES === | \\ |
| Type: /common/property_types/Basic Types/Array\\ The interior //d//-dimensional simplices of a cone of combinatorial dimension //d// | {{anchor:induced_subcomplex:}} **''induced_subcomplex([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> vertices)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''vertices'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the subcomplex consisting of all faces which are contained in the given set of //vertices//. |
| |
| === EXCESS_FACET_DEGREE === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Measures the deviation of the cone from being simple in terms of the [[/polytope/objects/Cone/properties/Combinatorics/DUAL_GRAPH]]. | {{anchor:foldable_prism:}} **''foldable_prism([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| | * Produce a __prism__ over a given ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]''. |
| |
| === SIMPLE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the facets of the cone are simple. Dual to [[/polytope/objects/Cone/properties/Combinatorics/SIMPLICIAL]]. | {{anchor:edge_contraction:}} **''edge_contraction([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Heuristic 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. |
| |
| === MAX_BOUNDARY_SIMPLICES === | \\ |
| Type: /common/property_types/Basic Types/Array\\ The boundary (//d//-1)-dimensional simplices of a cone of combinatorial dimension //d// | {{anchor:disjoint_union:}} **''disjoint_union([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __disjoint union__ of the two given complexes. |
| |
| === COMBINATORIAL_DIM === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Combinatorial dimension | {{anchor:stellar_subdivision:}} **''stellar_subdivision''** |
| This is the dimension all combinatorial properties of the cone | |
| like e.g. [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_FACETS]] or the [[/polytope/objects/Cone/properties/Combinatorics/HASSE_DIAGRAM]] refer to. | |
| |
| Geometrically, the combinatorial dimension is the dimension | \\ |
| of the intersection of the pointed part of the cone | {{anchor:web_of_stars:}} **''web_of_stars([[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> poset_hom, [[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>> star_shaped_balls, [[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>> triang)''** |
| with a hyperplane that creates a bounded intersection. | * //Parameters:// |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>'' ''poset_hom'' : the poset homomorphism from stabbing order to star-shaped balls |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>>'' ''star_shaped_balls'' : the collection of star-shaped balls of T |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>'' ''triang'' : the facets of the underlying triangulation of Q |
| | * //Returns:// ''[[playground/playground#IncidenceMatrix |IncidenceMatrix]]'' |
| | * Produce a web of stars from two given triangulations\\ and a map between them. |
| |
| === F_VECTOR === | \\ |
| Type: /common/property_types/Algebraic Types/Vector\\ The vector counting the number of faces (`f<sub>k</sub>` is the number of `(k+1)`-faces). | {{anchor:barycentric_subdivision:}} **''barycentric_subdivision([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Computes the __barycentric subdivision__ of //complex//. |
| | * //Example://\\ To subdivide a triangle into six new triangles, do this: \\ <code> > $b = barycentric_subdivision(simplex(2)); |
| | </code> |
| |
| ---- | \\ |
| ==== Lattice points in cones ==== | {{anchor:union:}} **''union([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| These properties capture information that depends on the lattice structure of the cone. | * //Parameters:// |
| polymake always works with the integer lattice. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the union of the two given complexes, identifying\\ vertices with equal labels. |
| |
| === H_STAR_VECTOR === | \\ |
| Type: /common/property_types/Algebraic Types/Vector\\ The coefficients of the Hilbert polynomial, | {{anchor:cone:}} **''cone([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| the h^*-polynomial for lattice polytopes, | * //Parameters:// |
| with respect to the [[/polytope/objects/Cone/properties/Lattice points in cones/MONOID_GRADING]] | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| starting at the constant coefficient. | * ''[[playground/playground#Int |Int]]'' ''k'' : default is 1 |
| For lattice polytopes the length of this vector is [[/polytope/objects/Cone/properties/Geometry/CONE_DIM]]. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| In general the length is one less than the degree of the | * Produce the //k//-cone over a given simplicial complex. |
| denominator of the [[/polytope/objects/Cone/properties/Lattice points in cones/HILBERT_SERIES]]. | * //Example://\\ The following creates the cone with two apices over the triangle,\\ with custom apex labels. The resulting complex is the 4-simplex. \\ <code> > $c = cone(simplex(2),2,apex_labels=>['foo','bar']); |
| | > print $c->FACETS; |
| | {0 1 2 3 4} |
| | </code>\\ \\ <code> > print $c->VERTEX_LABELS; |
| | 0 1 2 foo bar |
| | </code> |
| |
| === MONOID_GRADING === | \\ |
| Type: /common/property_types/Algebraic Types/Vector\\ A grading for the monoid given by the intersection of the cone with the | {{anchor:join_complexes:}} **''join_complexes([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| lattice Z^d, should be positive for all generators. | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Creates the join of //complex1// and //complex2//. |
| |
| If this property is not specified by the user there are two defaults: | \\ |
| For rational polytopes the affine hyperplane defined by (1,0,\ldots,0) will be used. | {{anchor:alexander_dual:}} **''alexander_dual([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| For [[/polytope/objects/Cone/properties/Lattice points in cones/HOMOGENEOUS]] cones the affine hyperplane containing the primitive generators | * //Parameters:// |
| will be used. | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Computes the Alexander dual complex, that is, the complements of all non-faces.\\ The vertex labels are preserved unless the //no_labels// flag is specified. |
| |
| === N_HILBERT_BASIS === | \\ |
| Type: /common/property_types/Basic Types/Int\\ The number of elements of the [[/polytope/objects/Cone/methods/Lattice points in cones/HILBERT_BASIS]]. | {{anchor:deletion:}} **''deletion([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : specified by vertex indices.\\ Please use ''[[playground/playground/SimplicialComplex#labeled_vertices |labeled_vertices]]'' if you want to specify the face by vertex labels. |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Remove the given //face// and all the faces containing it. |
| |
| === DEGREE_ONE_GENERATORS === | \\ |
| Type: /common/property_types/Algebraic Types/Matrix\\ Elements of the [[/polytope/objects/Cone/methods/Lattice points in cones/HILBERT_BASIS]] for the cone of degree 1 with respect | {{anchor:link_complex:}} **''link_complex([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| to the [[/polytope/objects/Cone/properties/Lattice points in cones/MONOID_GRADING]]. | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __link__ of a //face// of the //complex// |
| |
| === HILBERT_BASIS_GENERATORS === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Generators for the [[/polytope/objects/Cone/methods/Lattice points in cones/HILBERT_BASIS]] of a posiibly non-pointed cone | {{anchor:star:}} **''star([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| the first matrix is a Hilbert basis of a pointed part of the cone | * //Parameters:// |
| the second matrix is a lattice basis of the lineality space | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| note: the pointed part used in this property need not be the same as the one described by [[/polytope/objects/Cone/properties/Geometry/RAYS]] or [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]] | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : |
| it will be if the cone is pointed (the polytope is bounded) | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __star__ of the //face// of the //complex//. |
| |
| === GORENSTEIN_CONE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ A cone is [[/polytope/objects/Cone/properties/Lattice points in cones/GORENSTEIN_CONE|Gorenstein]] if it is [[/polytope/objects/Cone/properties/Lattice points in cones/Q_GORENSTEIN_CONE|Q-Gorenstein]] with index one | {{anchor:colored_ball_from_colored_sphere:}} **''colored_ball_from_colored_sphere([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Extends 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. |
| |
| === SMOOTH_CONE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ A cone is __smooth__ if the primitive generators are part of a lattice basis. | {{anchor:poset_homomorphisms:}} **''poset_homomorphisms([[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> P, [[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> Q)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' ''P'' : |
| | * ''[[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]>'' ''Q'' : |
| | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>>'' |
| | * Enumerate all order preserving maps from one poset to another |
| |
| === HOMOGENEOUS === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the primitive generators of the rays lie on an affine hyperplane in the span of the rays. | {{anchor:iterated_barycentric_subdivision:}} **''iterated_barycentric_subdivision([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Int |Int]]'' ''k'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Computes the //k//-th __barycentric subdivision__ of //complex// by iteratively calling ''[[playground/playground#barycentric |barycentric]]''. |
| |
| === HILBERT_SERIES === | \\ |
| Type: /common/property_types/Algebraic Types/RationalFunction\\ Hilbert series of the monoid, given by the intersection of the cone with | {{anchor:k_skeleton:}} **''k_skeleton''** |
| the lattice Z^d with respect to the [[/polytope/objects/Cone/properties/Lattice points in cones/MONOID_GRADING]] | |
| |
| === Q_GORENSTEIN_CONE_INDEX === | \\ |
| Type: /common/property_types/Basic Types/Int\\ If a cone is [[/polytope/objects/Cone/properties/Lattice points in cones/Q_GORENSTEIN_CONE|Q-Gorenstein]], then its index is the common lattice height of the primitive generators with respect to the origin. Otherwise Q_GORENSTEIN_CONE_INDEX is undefined. | {{anchor:suspension:}} **''suspension([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| | * ''[[playground/playground#Int |Int]]'' ''k'' : default value is 1 |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __//k//-suspension__ over a given simplicial complex. |
| |
| === Q_GORENSTEIN_CONE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ A cone is __Q-Gorenstein__ if all primitive generators of the cone lie in an affine hyperplane spanned by a lattice functional in the dual cone (but not in the lineality space of the dual cone). | {{anchor:bs2quotient:}} **''bs2quotient([[playground/playground/Polytope# |Polytope]] P, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/Polytope# |Polytope]]'' ''P'' : the underlying polytope |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : a sufficiently fine subdivision of P, for example the second barycentric subdivision |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Create 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. |
| |
| ---- | ---- |
| ==== Geometry ==== | ==== Producing a simplicial complex from other objects ==== |
| These properties capture geometric information of the object. | These functions construct a new [[/topaz/objects/SimplicialComplex]] from other objects. |
| Geometric properties depend on geometric information of the object, like, e.g., vertices or facets. | \\ |
| | {{anchor:vietoris_rips_complex:}} **''vietoris_rips_complex([[playground/playground#Matrix |Matrix]] D, [[playground/playground#Rational |Rational]] delta)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Matrix |Matrix]]'' ''D'' : the "distance matrix" of the point set (can be upper triangular) |
| | * ''[[playground/playground#Rational |Rational]]'' ''delta'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Computes the __Vietoris Rips complex__ of a point set. The set is passed as its so-called "distance matrix", whose (i,j)-entry is the distance between point i and j. This matrix can e.g. be computed using the distance_matrix function. The points corresponding to vertices of a common simplex will all have a distance less than //delta// from each other. |
| |
| === N_EQUATIONS === | \\ |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Cone/properties/Input property/EQUATIONS]]. | {{anchor:independence_complex:}} **''independence_complex([[playground/playground/Matroid# |Matroid]] matroid)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/Matroid# |Matroid]]'' ''matroid'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __independence complex__ of a given matroid.\\ If //no_labels// is set to 1, the labels are not copied. |
| |
| === LINEALITY_SPACE === | \\ |
| Type: /common/property_types/Algebraic Types/Matrix\\ Basis of the linear subspace orthogonal to all [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]] and [[/polytope/objects/Cone/properties/Input property/EQUATIONS]] | {{anchor:clique_complex:}} **''clique_complex([[playground/playground/Graph# |Graph]] graph)''** |
| All vectors in this section must be non-zero. | * //Parameters:// |
| The property [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]] appears only in conjunction with the property [[/polytope/objects/Cone/properties/Geometry/RAYS]], or [[/polytope/objects/SchlegelDiagram/properties/VERTICES]], respectively. | * ''[[playground/playground/Graph# |Graph]]'' ''graph'' : |
| The specification of the property [[/polytope/objects/Cone/properties/Geometry/RAYS]] or [[/polytope/objects/SchlegelDiagram/properties/VERTICES]] requires the specification of [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]], and vice versa. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __clique complex__ of a given graph, that is, the simplicial\\ complex that has an n-dimensional facet for each n+1-clique.\\ If //no_labels// is set to 1, the labels are not copied. |
| | * //Example://\\ Create the clique complex of a simple graph with one 3-clique and\\ one 2-clique, not creating labels. \\ <code> > $g = graph_from_edges([[0,1],[0,2],[1,2],[2,3]]); |
| | > $c = clique_complex($g,no_labels=>1); |
| | > print $c->FACETS; |
| | {0 1 2} |
| | {2 3} |
| | </code> |
| |
| === REL_INT_POINT === | ---- |
| Type: /common/property_types/Algebraic Types/Vector\\ A point in the relative interior of the cone. | ==== Producing from scratch ==== |
| | With these clients you can create special examples of simplicial complexes and complexes belonging to parameterized families. |
| | \\ |
| | {{anchor:torus:}} **''torus''** |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * The Császár Torus. Geometric realization by Frank Lutz,\\ Electronic Geometry Model No. 2001.02.069 |
| |
| === POINTED === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the cone does not contain a non-trivial linear subspace. | {{anchor:simplex:}} **''simplex([[playground/playground#Int |Int]] d)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * A __simplex__ of dimension //d//. |
| |
| === INPUT_RAYS_IN_FACETS === | \\ |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS|Input ray]]-[[/polytope/objects/Cone/properties/Geometry/FACETS|facet]] incidence matrix, with rows corresponding to [[/polytope/objects/Cone/properties/Geometry/FACETS|facet]] and columns | {{anchor:complex_projective_plane:}} **''complex_projective_plane''** |
| to [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS|input rays]]. Input_rays and facets are numbered from 0 to [[/polytope/objects/Cone/properties/Geometry/N_INPUT_RAYS]]-1 rsp. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| [[/polytope/objects/Cone/properties/Geometry/N_FACETS]]-1, according to their order in [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]] | * The complex projective plane with the vertex-minimal triangulation by Kühnel and Brehm. |
| rsp. [[/polytope/objects/Cone/properties/Geometry/FACETS]]. | * //Example://\\ Construct the complex projective plane, store it in the variable $p2c, and print its homology group. \\ <code> > $p2c = complex_projective_plane(); |
| | > print $p2c->HOMOLOGY; |
| | ({} 0) |
| | ({} 0) |
| | ({} 1) |
| | ({} 0) |
| | ({} 1) |
| | </code> |
| |
| === CONE_AMBIENT_DIM === | \\ |
| Type: /common/property_types/Basic Types/Int\\ The dimension of the space in which the cone lives. | {{anchor:ball:}} **''ball([[playground/playground#Int |Int]] d)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| | * A //d//-dimensional __ball__, realized as the //d//-simplex. |
| | * //Example://\\ The following produces the 3-ball and stores it in the variable $b: \\ <code> > $b = ball(3); |
| | </code>\\ You can print the facets of the resulting simplicial complex like so: \\ <code> > print $b->FACETS; |
| | {0 1 2 3} |
| | </code> |
| |
| === TRIVIAL === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if the only valid point in the cone is the unique non-sensical point (0,...,0) | {{anchor:cube_complex:}} **''cube_complex([[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> x)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]>'' ''x'' : specifies the shape of the pile:\\ d=x.size is the dimension of the cubes to be stacked, and the stack will be\\ x_1 by x_2 by ... by x_d cubes. |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]<[[playground/playground#Rational |Rational]]>'' |
| | * Produces a triangulated pile of hypercubes, arranged in a d-dimensional array.\\ Each cube is split into d! tetrahedra, and the tetrahedra are all grouped around\\ one of the diagonal axes of the cube. |
| | * //Example://\\ Arrange four triangulated 3-cubes to form a big 2 by 2 cube: \\ <code> > $cc = cube_complex([2,2,2]); |
| | > print $cc->description; |
| | 2x2x2 Pile of 3-dimensional triangulated cubes. |
| | </code> |
| |
| === LINEALITY_DIM === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Dimension of the [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]] (>0 in the non-POINTED case) | {{anchor:surface:}} **''surface([[playground/playground#Int |Int]] g)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''g'' : genus |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce a __surface of genus //g//__. For //g// >= 0\\ the client produces an orientable surface, otherwise\\ it produces a non-orientable one. |
| |
| === EPSILON === | \\ |
| Type: /common/property_types/Basic Types/Float\\ Threshold for zero test for scalar products (e.g. vertex * facet normal) | {{anchor:rand_knot:}} **''rand_knot([[playground/playground#Int |Int]] n_edges)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''n_edges'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce 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]<sup>3</sup>, 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. |
| |
| === RAYS === | \\ |
| Type: /common/property_types/Algebraic Types/Matrix\\ Rays of the cone. No redundancies are allowed. | {{anchor:klein_bottle:}} **''klein_bottle''** |
| All vectors in this section must be non-zero. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| The property [[/polytope/objects/Cone/properties/Geometry/RAYS]] appears only in conjunction with the property [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]]. | * The Klein bottle. |
| The specification of the property [[/polytope/objects/Cone/properties/Geometry/RAYS]] requires the specification of [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]], and vice versa. | |
| |
| === N_INPUT_LINEALITY === | \\ |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Cone/properties/Input property/INPUT_LINEALITY]]. | {{anchor:multi_associahedron_sphere:}} **''multi_associahedron_sphere([[playground/playground#Int |Int]] n, [[playground/playground#Int |Int]] k)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''n'' : the number of vertices of the polygon |
| | * ''[[playground/playground#Int |Int]]'' ''k'' : the number of diagonals that are allowed to mutually cross |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the simplicial sphere //Δ(n,k)// of (//k//+1)-crossing free multitriangulations\\ of an //n//-gon //P//, along with the group action on the diagonals induced from //D//_{2//n//}.\\ //Δ(n,k)// is the simplicial complex on the set of relevant diagonals of //P// whose faces are those sets\\ of diagonals such that no //k//+1 of them mutually cross. A diagonal is //relevant// if it leaves\\ //k// or more vertices of //P// on both sides. (Any diagonal having less than //k// vertices on one\\ side trivially cannot participate in a (//k//+1)-crossing, so is //irrelevant//. The corresponding\\ complex on //all// diagonals is therefore the simplicial join of this one with the simplex of irrelevant\\ diagonals.)\\ Jakob Jonsson, "Generalized triangulations and diagonal-free subsets of stack polyominoes",\\ J. Combin. Theory Ser. A, 112(1):117–142, 2005\\ //Delta(n,k)// is known to be a //k//-neighborly vertex-decomposable sphere of dimension //k//ν-1,\\ where the parameter ν=//n//-2//k//-1 measures the complexity of this construction.\\ For ν=0, the complex is a point; for ν=1 a //k//-simplex; for ν=2 the boundary of a cyclic polytope.\\ Setting //k//=1 yields the boundary of the simplicial associahedron.\\ The list of (//k//+1)-crossings in the //n//-gon is included as the attachment K_PLUS_1_CROSSINGS. It can\\ also be obtained as the property MINIMAL_NON_FACES, but this requires the HASSE_DIAGRAM to be computed. |
| | * //Example://\\ The f-vector of Δ(9,3) is that of a neighborly polytope, since ν=2: \\ <code> > print multi_associahedron_sphere(9,3)->F_VECTOR; |
| | 9 36 84 117 90 30 |
| | </code> |
| | * //Example://\\ The option no_facets=>1 still leaves useful information: \\ <code> > $s = multi_associahedron_sphere(8,2, no_facets=>1); |
| | > print $s->VERTEX_LABELS; |
| | (0 3) (1 4) (2 5) (3 6) (4 7) (0 5) (1 6) (2 7) (0 4) (1 5) (2 6) (3 7) |
| | </code>\\ \\ <code> > print $s->GROUP->PERMUTATION_ACTION->GENERATORS; |
| | 7 0 1 2 3 4 5 6 11 8 9 10 |
| | 4 3 2 1 0 7 6 5 11 10 9 8 |
| | </code>\\ \\ <code> > print $s->get_attachment("K_PLUS_1_CROSSINGS")->size(); |
| | 28 |
| | </code> |
| |
| === CONE_DIM === | \\ |
| Type: /common/property_types/Basic Types/Int\\ Dimension of the linear span of the cone = dimension of the cone. | {{anchor:real_projective_plane:}} **''real_projective_plane''** |
| If the cone is given purely combinatorially, this is the dimension of a minimal embedding space | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| deduced from the combinatorial structure. | * The real projective plane with its unique minimal triangulation on six vertices. |
| |
| === RAYS_IN_INEQUALITIES === | \\ |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ Ray-inequality incidence matrix, with rows corresponding to facets and columns | {{anchor:unknot:}} **''unknot([[playground/playground#Int |Int]] m, [[playground/playground#Int |Int]] n)''** |
| to rays. Rays and inequalities are numbered from 0 to [[/polytope/objects/Cone/properties/Combinatorics/N_RAYS]]-1 rsp. | * //Parameters:// |
| number of [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]]-1, according to their order in [[/polytope/objects/Cone/properties/Geometry/RAYS]] | * ''[[playground/playground#Int |Int]]'' ''m'' : |
| rsp. [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]]. | * ''[[playground/playground#Int |Int]]'' ''n'' : |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| | * Produces 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 ''[[playground/playground/GeometricSimplicialComplex#COORDINATES |COORDINATES]]''. |
| |
| === POSITIVE === | \\ |
| Type: /common/property_types/Basic Types/Bool\\ True if all [[/polytope/objects/Cone/properties/Geometry/RAYS]] of the cone have non-negative coordinates, | {{anchor:sphere:}} **''sphere([[playground/playground#Int |Int]] d)''** |
| that is, if the pointed part of the cone lies entirely in the positive orthant. | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| === N_INPUT_RAYS === | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]]. | * The //d//-dimensional __sphere__, realized as the boundary of the (//d//+1)-simplex. |
| | |
| === FACETS_THRU_INPUT_RAYS === | |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ Transposed to [[/polytope/objects/Cone/properties/Geometry/INPUT_RAYS_IN_FACETS]]. | |
| Notice that this is a temporary property; it will not be stored in any file. | |
| | |
| === FACETS === | |
| Type: /common/property_types/Algebraic Types/Matrix\\ Facets of the cone, encoded as inequalities. | |
| All vectors in this section must be non-zero. | |
| Dual to [[/polytope/objects/Cone/properties/Geometry/RAYS]]. | |
| This section is empty if and only if the cone is trivial (e.g. if it encodes an empty polytope). | |
| Notice that a polytope which is a single point defines a one-dimensional cone, the face at infinity is a facet. | |
| The property [[/polytope/objects/Cone/properties/Geometry/FACETS]] appears only in conjunction with the property [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]], or [[/polytope/objects/PointConfiguration/properties/Geometry/AFFINE_HULL]], respectively. | |
| The specification of the property [[/polytope/objects/Cone/properties/Geometry/FACETS]] requires the specification of [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]], | |
| or [[/polytope/objects/PointConfiguration/properties/Geometry/AFFINE_HULL]], respectively, and vice versa. | |
| | |
| === INEQUALITIES_THRU_RAYS === | |
| Type: /common/property_types/Set Types/IncidenceMatrix\\ transposed [[/polytope/objects/Cone/properties/Geometry/RAYS_IN_INEQUALITIES]] | |
| Notice that this is a temporary property; it will not be stored in any file. | |
| | |
| === ONE_RAY === | |
| Type: /common/property_types/Algebraic Types/Vector\\ A ray of a pointed cone. | |
| | |
| === LINEAR_SPAN === | |
| Type: /common/property_types/Algebraic Types/Matrix\\ Dual basis of the linear span of the cone. | |
| All vectors in this section must be non-zero. | |
| The property [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]] appears only in conjunction with the property [[/polytope/objects/Cone/properties/Geometry/FACETS]]. | |
| The specification of the property [[/polytope/objects/Cone/properties/Geometry/FACETS]] requires the specification of [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]], | |
| or [[/polytope/objects/PointConfiguration/properties/Geometry/AFFINE_HULL]], respectively, and vice versa. | |
| | |
| === FULL_DIM === | |
| Type: /common/property_types/Basic Types/Bool\\ [[/polytope/objects/Cone/properties/Geometry/CONE_AMBIENT_DIM]] and [[/polytope/objects/Cone/properties/Geometry/CONE_DIM]] coincide. Notice that this makes sense also for the derived Polytope class. | |
| | |
| === RAY_SEPARATORS === | |
| Type: /common/property_types/Algebraic Types/Matrix\\ The i-th row is the normal vector of a hyperplane separating the i-th vertex from the others. | |
| This property is a by-product of redundant point elimination algorithm. | |
| | |
| === N_RIDGES === | |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Symmetry/SymmetrizedCocircuitEquations/properties/RIDGES]]. | |
| | |
| === N_FACETS === | |
| Type: /common/property_types/Basic Types/Int\\ The number of [[/polytope/objects/Cone/properties/Geometry/FACETS]]. | |
| |
| ---- | ---- |
| ==== Symmetry ==== | ==== Producing other objects ==== |
| These properties capture information of the object that is concerned with the action of permutation groups. | Functions producing big objects which are not contained in application topaz. |
| | \\ |
| | {{anchor:secondary_polyhedron:}} **''secondary_polyhedron([[playground/playground/HyperbolicSurface# |HyperbolicSurface]] s, [[playground/playground#Int |Int]] depth)''** |
| | * //Parameters:// |
| | * ''[[playground/playground/HyperbolicSurface# |HyperbolicSurface]]'' ''s'' : |
| | * ''[[playground/playground#Int |Int]]'' ''depth'' : |
| | * //Returns:// ''[[playground/playground/Polytope# |Polytope]]<[[playground/playground#Float |Float]]>'' |
| | * Computes the secondary polyhedron of a hyperbolic surface up to a given depth\\ of the spanning tree of the covering triangluation of the hypoerbolic plane. |
| |
| === GROUP === | |
| Type: /polytope/objects/Cone/properties/Symmetry/GROUP\\ **Properties of GROUP**:\\ **Symmetry**\\ These properties capture information of the object that is concerned with the action of permutation groups. | |
| * **REPRESENTATIVE_MAX_INTERIOR_SIMPLICES**\\ Type: /common/property_types/Basic Types/Array\\ One representative for each orbit of maximal-dimensional interior simplices | |
| * **REPRESENTATIVE_INTERIOR_RIDGE_SIMPLICES**\\ Type: /common/property_types/Basic Types/Array\\ One representative for each orbit of interior ridge simplices | |
| * **BITSET_ACTION**\\ Type: /group/objects/ImplicitActionOnSets * **REPRESENTATIVE_MAX_BOUNDARY_SIMPLICES**\\ Type: /common/property_types/Basic Types/Array\\ One representative for each orbit of maximal-dimensional boundary simplices | |
| * **MATRIX_ACTION**\\ Type: /polytope/objects/Cone/properties/Symmetry/GROUP/properties/Symmetry/MATRIX_ACTION\\ **Properties of MATRIX_ACTION**:\\ **Symmetry**\\ These properties capture information of the object that is concerned with the action of permutation groups. | |
| * **RAYS_ORBITS**\\ Type: /common/property_types/Basic Types/Array\\ Alias for property [[/group/objects/MatrixActionOnVectors/properties/Symmetry/VECTORS_ORBITS]]. | |
| * **REPRESENTATIVE_RAYS**\\ Type: /common/property_types/Algebraic Types/Matrix * **REPRESENTATIVE_BOUNDARY_RIDGE_SIMPLICES**\\ Type: /common/property_types/Basic Types/Array\\ One representative for each orbit of boundary ridge simplices | |
| * **REPRESENTATIVE_FACETS**\\ Type: /common/property_types/Algebraic Types/Matrix | |
| ---- | ---- |
| ==== Visualization ==== | ==== Topology ==== |
| These properties are for visualization. | The following functions compute topological invariants. |
| | \\ |
| | {{anchor:test:}} **''test''** |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Calculate the betti numbers of a general chain complex over a field. |
| |
| === FACET_LABELS === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Unique names assigned to the [[/polytope/objects/Cone/properties/Geometry/FACETS]], analogous to [[/polytope/objects/Cone/properties/Visualization/RAY_LABELS]]. | {{anchor:homology_and_cycles:}} **''homology_and_cycles''** |
| |
| === INPUT_RAY_LABELS === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Unique names assigned to the [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]], analogous to [[/polytope/objects/Cone/properties/Visualization/RAY_LABELS]]. | {{anchor:betti_numbers:}} **''betti_numbers''** |
| |
| === NEIGHBOR_RAYS_CYCLIC_NORMAL === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Reordered [[/polytope/objects/Cone/properties/Combinatorics/GRAPH]]. Dual to [[/polytope/objects/Cone/properties/Visualization/NEIGHBOR_FACETS_CYCLIC_NORMAL]]. | {{anchor:homology:}} **''homology''** |
| |
| === COORDINATE_LABELS === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Unique names assigned to the coordinate directions, analogous to [[/polytope/objects/Cone/properties/Visualization/RAY_LABELS]]. | {{anchor:cap_product:}} **''cap_product([[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]] cocycles, [[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]] cycles)''** |
| For Polytopes this should contain "inhomog_var" for the homogenization coordinate and this will | * //Parameters:// |
| be added automatically if necessary and [[/polytope/objects/Cone/properties/Geometry/CONE_AMBIENT_DIM]] can be computed. | * ''[[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]]'' ''cocycles'' : |
| | * ''[[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]]'' ''cycles'' : |
| | * //Returns:// ''[[playground/playground#Pair |Pair]]<[[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]]'' |
| | * Compute all cap products of cohomology and homology cycles in two given groups. |
| | * //Example://\\ The following stores all cap products of the cocycles and cycles\\ of the homology group of the oriented surface of genus 1 in the variable $cp. \\ <code> > $s = surface(1); |
| | > $cp = cap_product($s->COCYCLES->[1],$s->CYCLES->[1]); |
| | </code> |
| | ===== Small Object Types ===== |
| |
| === RAY_LABELS === | ---- |
| Type: /common/property_types/Basic Types/Array\\ Unique names assigned to the [[/polytope/objects/Cone/properties/Geometry/RAYS]]. | ==== Topology ==== |
| If specified, they are shown by visualization tools instead of ray indices. | The following property_types are topological invariants. |
| | \\ |
| | {{anchor:filtration:}} **''Filtration<MatrixType>''** |
| | * //Template Parameters:// |
| | * ''MatrixType'' : |
| | * A filtration of chain complexes. |
| | * //Methods of Filtration:// |
| | * **''dim''** |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Returns the dimension of the maximal cells in the last frame of the filtration. |
| | * **''n_cells''** |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Returns the number of cells in the last frame of the filtration. |
| | * **''cells''** |
| | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#Cell |Cell]]>'' |
| | * Returns the cells of the filtration, given as array of 3-tuples containing degree, dimension and\\ boundary matrix row number of the cell. |
| | * **''boundary_matrix([[playground/playground#Int |Int]] d, [[playground/playground#Int |Int]] t)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : |
| | * ''[[playground/playground#Int |Int]]'' ''t'' : |
| | * Returns the d-boundary matrix of the t-th frame of the filtration. |
| | * **''n_frames''** |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Returns the number of frames in of the filtration. |
| |
| For a cone built from scratch, you should create this property by yourself, | \\ |
| either manually in a text editor, or with a client program. If you build a cone with a construction client | {{anchor:chaincomplex:}} **''ChainComplex<MatrixType>''** |
| taking some other input cone(s), you can create the labels automatically if you | * //Template Parameters:// |
| call the client with a //relabel// option. The exact format of the labels is dependent on the | * ''MatrixType'' : The type of the differential matrices. default: SparseMatrix<Integer> |
| construction, and is described by the corresponding client. | * A finite chain complex, represented as its boundary matrices.\\ Check out the tutorial on the polymake homepage for examples on constructing ChainComplexes and computing their homology. |
| | * //Example://\\ You can create a new ChainComplex by passing the Array of differential matrices (as maps via _left_ multiplication): \\ <code> > $cc = new ChainComplex(new Array<SparseMatrix<Integer>>([[[2,0]]])); |
| | </code>\\ Note that this creates a ChainComplex consisting three differential matrices -- the trivial zeroth and last ones\\ are omitted in the constructor.\\ You can look at the boundary matrices: \\ <code> > print $cc->boundary_matrix(1); |
| | 2 0 |
| | </code>\\ The functions ''homology'', ''homology_and_cycles'' and ''betti_numbers'' can be used to analyse your complex. \\ <code> > print homology($cc,0); |
| | ({(2 1)} 1) |
| | ({} 0) |
| | </code> |
| | * //Methods of ChainComplex:// |
| | * **''boundary_matrix([[playground/playground#Int |Int]] d)''** |
| | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : |
| | * //Returns:// ''[[playground/playground#ChainComplex |ChainComplex]]'' |
| | * Returns the d-boundary matrix of the chain complex. |
| | * **''dim''** |
| | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Returns the number of non-empty modules in the complex. |
| |
| === FTR_CYCLIC_NORMAL === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Reordered transposed [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_FACETS]]. Dual to [[/polytope/objects/Cone/properties/Visualization/RIF_CYCLIC_NORMAL]]. | {{anchor:cell:}} **''Cell''** |
| | * |
| |
| === NEIGHBOR_FACETS_CYCLIC_NORMAL === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Reordered [[/polytope/objects/Cone/properties/Combinatorics/DUAL_GRAPH]] for 3d-cones. | {{anchor:cyclegroup:}} **''CycleGroup<Scalar>''** |
| The neighbor facets are listed in the order corresponding to [[/polytope/objects/Cone/properties/Visualization/RIF_CYCLIC_NORMAL]], | * //Template Parameters:// |
| so that the first two vertices in RIF_CYCLIC_NORMAL make up the ridge to the first neighbor | * ''Scalar'' : integer type of matrix elements |
| facet and so on. | * 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. |
| | |
| === INEQUALITY_LABELS === | |
| Type: /common/property_types/Basic Types/Array\\ Unique names assigned to the [[/polytope/objects/Cone/properties/Input property/INEQUALITIES]], analogous to [[/polytope/objects/Cone/properties/Visualization/RAY_LABELS]]. | |
| | |
| === RIF_CYCLIC_NORMAL === | |
| Type: /common/property_types/Basic Types/Array\\ Reordered [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_FACETS]] for 2d and 3d-cones. | |
| Rays are listed in the order of their appearance | |
| when traversing the facet border counterclockwise seen from outside of the origin. | |
| | |
| ---- | |
| ==== Triangulation and volume ==== | |
| These properties collect information about triangulations of the object and properties usually computed from such, as the volume. | |
| |
| === TRIANGULATION_INT === | \\ |
| Type: /common/property_types/Basic Types/Array\\ Conceptually, similar to [[/polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION]], but using [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]]. | {{anchor:intersectionform:}} **''IntersectionForm''** |
| However, here we use a small object type. The main reason for the existence of this property | * Parity and signature of the intersection form of a closed oriented 4k-manifold.\\ See ''[[playground/playground/SimplicialComplex#INTERSECTION_FORM |INTERSECTION_FORM]]''. |
| (in this form) is the [[/polytope/preferences/Convex hull computation/beneath_beyond]] algorithm, which automatically produces this data as | |
| a by-product of the conversion from [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]] to [[/polytope/objects/Cone/properties/Geometry/FACETS]]. And that data is too valuable | |
| to throw away. Use big objects of type [[/polytope/objects/Geometry/VectorConfiguration]] if you want to work with | |
| triangulations using redundant points. | |
| |
| === TRIANGULATION === | \\ |
| Type: /polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION\\ Some triangulation of the cone using only its [[/polytope/objects/Cone/properties/Geometry/RAYS]]. | {{anchor:homologygroup:}} **''HomologyGroup''** |
| \\ **Properties of TRIANGULATION**:\\ **Combinatorics**\\ These properties capture combinatorial information of the object. | * A group is encoded as a sequence ( { (t<sub>1</sub> m<sub>1</sub>) ... (t<sub>n</sub> m<sub>n</sub>) } f) of non-negative integers,\\ with t<sub>1</sub> > t<sub>2</sub> > ... > t<sub>n</sub> > 1, plus an extra non-negative integer f.\\ The group is isomorphic to (Z/t<sub>1</sub>)<sup>m<sub>1</sub></sup> × ... × (Z/t<sub>n</sub>)<sup>m<sub>n</sub></sup> × Z<sup>f</sup>, \\ where Z<sup>0</sup> is the trivial group.\\ Access methods: //torsion// delivers the list of Z-groups, //betti_number// the number f. |
| Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice. | |
| * **REFINED_SPLITS**\\ Type: /common/property_types/Set Types/Set\\ The splits that are coarsenings of the current [[/polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION]]. | |
| If the triangulation is regular these form the unique split decomposition of | |
| the corresponding weight function. | |
| * **BOUNDARY**\\ Type: /polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION/properties/Combinatorics/BOUNDARY\\ Augmented subobject [[topaz::SimplicialComplex::BOUNDARY | |
| \\ **Properties of BOUNDARY**:\\ **no category**\\ * **FACET_TRIANGULATIONS**\\ Type: /common/property_types/Basic Types/Array\\ For each facet the set of simplex indices of [[/polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION/properties/Combinatorics/BOUNDARY]] that triangulate it. | |
| **Geometry**\\ These properties capture geometric information of the object. | |
| Geometric properties depend on geometric information of the object, like, e.g., vertices or facets. | |
| * **WEIGHTS**\\ Type: /common/property_types/Algebraic Types/Vector\\ Weight vector to construct a regular [[/polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION]]. | |
| Must be generic. | |
| |