| Both sides previous revision Previous revision Next revision | Previous revisionLast revisionBoth sides next revision |
| playground:playground [2019/03/20 16:04] – oroehrig | playground:playground [2019/03/25 20:59] – oroehrig |
|---|
| ====== BigObject Polytope ====== | ====== application topaz ====== |
| Not necessarily bounded convex polyhedron, i.e., the feasible region of a linear program. | 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. |
| Nonetheless, the name "Polytope" is used for two reasons: Firstly, as far as the combinatorics | imports from: |
| is concerned we always deal with polytopes; see the description of [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] for details. | * [[graph|application graph]] |
| Note that a pointed polyhedron is projectively equivalent to a polytope. | * [[common|application common]] |
| The second reason is historical. | uses: |
| We use homogeneous coordinates, which is why Polytope is derived from [[/polytope/objects/Cone]]. | * [[ideal|application ideal]] |
| | * [[group|application group]] |
| **derived from** ['[[polytope/Cone | Cone]]'] | ===== 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. |
| **Specializations**: | * [[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). |
| * ''Polytope::Lattice'': A polytope all of whose vertex coordinates are integral. | * [[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. |
| * ''Polytope<Float>'': A pointed polyhedron with float coordinates realized in R<sup>d</sup>. | * [[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. |
| It mainly exists for visualization. | ===== Functions ===== |
| | |
| Convex hull and related algorithms use floating-point arithmetics. | |
| Due to numerical errors inherent to this kind of computations, the resulting | |
| combinatorial description can be arbitrarily far away from the truth, or even | |
| not correspond to any valid polytope. You have been warned. | |
| | |
| None of the standard construction clients produces objects of this type. | |
| If you want to get one, create it with the explicit constructor or [[/polytope/functions/Coordinate conversions/convert_to]]. | |
| | |
| * ''Symmetry'': These specializations capture information of the object that is concerned with the action of permutation groups. | |
| | |
| * ''Polytope<Rational>'': A rational polyhedron realized in Q^d | |
| | |
| | |
| **Examples**: | |
| * //Example://\\ To construct a polytope as the convex hull of three points in the plane use \\ <code> > $p=new Polytope(POINTS=>[[1,0,0],[1,1,0],[1,0,1]]); | |
| print $p->N_FACETS | |
| 3 | |
| </code>\\ Note that homogeneous coordinates are used throughout. \\ | |
| * //Example://\\ Many standard constructions are available directly. For instance, to get a regular 120-cell (which is 4-dimensional) use: \\ <code> > $c=regular_120_cell(); | |
| print $c->VOLUME; | |
| 1575+705r5 | |
| </code>\\ This is the exact volume 1575+705*\sqrt{5}.\\ polymake has limited support for polytopes with non-rational coordinates. \\ | |
| ===== Properties ===== | |
| |
| ---- | ---- |
| ==== Combinatorics ==== | ==== Combinatorics ==== |
| These properties capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice. | 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:H_VECTOR:}} **''H_VECTOR''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{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)''** |
| * h-vector, defined via recursion on the face lattice of a polytope.\\ Coincides for simplicial polytopes with the combinatorial definition\\ of the h-vector via shellings | * //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. |
| |
| {{anchor:CUBICAL:}} **''CUBICAL''** | ---- |
| * //Type:// [[common:Basic Types#Bool | Bool]] | ==== Comparing ==== |
| * True if all facets are cubes. | These functions compare two [[/topaz/objects/SimplicialComplex]] |
| * //Example://\\ A k-dimensional cube has k-1-dimensional cubes as facets and is therefore cubical. The following checks if this holds for the\\ 3-dimensional case: \\ <code> > print cube(3)->CUBICAL; | \\ |
| true | {{anchor:isomorphic:}} **''isomorphic([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| </code> | * //Parameters:// |
| * //Example://\\ This checks if a zonotope generated by 4 random points on the 3-dimensional sphere is cubical, which is always the case. \\ <code> > print zonotope(rand_sphere(3,4)->VERTICES)->CUBICAL; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| true | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| </code> | * //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. |
| |
| {{anchor:MINIMAL_NON_FACES:}} **''MINIMAL_NON_FACES''** | \\ |
| * //Type:// [[common:Basic Types#Array | Array]] | {{anchor:find_facet_vertex_permutations:}} **''find_facet_vertex_permutations([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| * Minimal non-faces of a [[/polytope/objects/Polytope/properties/Combinatorics/SIMPLICIAL]] polytope. | * //Parameters:// |
| | * ''[[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. |
| |
| {{anchor:GRAPH:}} **''GRAPH''** | \\ |
| * //Type:// [[graph/Graph | Graph]] | {{anchor:pl_homeomorphic:}} **''pl_homeomorphic([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| * //Properties of GRAPH:// | * //Parameters:// |
| * **''EDGE_DIRECTIONS''** | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| * Difference of the vertices for each edge (only defined up to signs). | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| * **''SQUARED_EDGE_LENGTHS''** | * 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. |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | |
| * Squared Euclidean length of each edge | |
| * **''LATTICE_ACCUMULATED_EDGE_LENGTHS''** | |
| * //Type:// [[common:Set Types#Map | Map]] | |
| * a map associating to each edge length of the polytope the number of edges with this length\\ the lattice edge length of an edge is one less than the number of lattice points on that edge | |
| * **''LATTICE_EDGE_LENGTHS''** | |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | |
| * the lattice lengths of the edges of the polytope\\ i.e. for each edge one less than the number of lattice points on that edge | |
| |
| {{anchor:COMPLEXITY:}} **''COMPLEXITY''** | ---- |
| * //Type:// [[common:Basic Types#Float | Float]] | ==== Other ==== |
| * Parameter describing the shape of the face-lattice of a 4-polytope. | Special purpose functions. |
| | \\ |
| | {{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 |
| |
| {{anchor:G_VECTOR:}} **''G_VECTOR''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:is_vertex_decomposition:}} **''is_vertex_decomposition([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> vertices)''** |
| * (Toric) g-vector, defined via the (generalized) h-vector as g<sub>i</sub> = h<sub>i</sub> - h<sub>i-1</sub>. | * //Parameters:// |
| | * ''[[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! |
| |
| {{anchor:COCUBICAL:}} **''COCUBICAL''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:stiefel_whitney:}} **''stiefel_whitney([[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>> facets)''** |
| * Dual to [[/polytope/objects/Polytope/properties/Combinatorics/CUBICAL]]. | * //Parameters:// |
| * //Example://\\ Since the cross-polytope is dual to a cube of same dimension, it is cocubical. The following checks this for the 3-dimensional case: \\ <code> > print cross(3)->COCUBICAL; | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>'' ''facets'' : the facets of the simplicial complex |
| true | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#PowerSet |PowerSet]]<[[playground/playground#Int |Int]]>>'' |
| </code> | * 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 |
| |
| {{anchor:DUAL_GRAPH:}} **''DUAL_GRAPH''** | \\ |
| * //Type:// [[graph/Graph | Graph]] | {{anchor:star_of_zero:}} **''star_of_zero([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] C)''** |
| * //Properties of DUAL_GRAPH:// | * //Parameters:// |
| * **''DIHEDRAL_ANGLES''** | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''C'' : |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | * //Returns:// ''[[playground/playground#Set |Set]]<[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>>'' |
| * Dihedral angles (in radians) between the two facets corresponding to\\ each edge of the dual graph, i.e. the ridges of the polytope. | * 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 |
| |
| {{anchor:EDGE_ORIENTATION:}} **''EDGE_ORIENTATION''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:mixed_graph:}} **''mixed_graph([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * List of all edges with orientation, such that for each 2-face the opposite edges point in the same direction.\\ Each line is of the form (u v), which indicates that the edge {u,v} is oriented from u to v.\\ The polytope is required to be 2-cubical. | * //Parameters:// |
| * //Example://\\ The following prints a list of oriented edges of a 2-dimensional cube such that opposing edges have the same orientation: \\ <code> > $p = cube(2); | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $p->EDGE_ORIENTATION; | * Produces the mixed graph of a //complex//. |
| 0 2 | |
| 1 3 | |
| 0 1 | |
| 2 3 | |
| </code> | |
| |
| {{anchor:F2_VECTOR:}} **''F2_VECTOR''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:star_shaped_balls:}} **''star_shaped_balls([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P)''** |
| * f<sub>ik</sub> is the number of incident pairs of i-faces and k-faces; the main diagonal contains the [[/polytope/objects/Polytope/properties/Combinatorics/F_VECTOR]]. | * //Parameters:// |
| * //Example://\\ The following prints the f2-vector of a 3-dimensional cube: \\ <code> > print cube(3)->F2_VECTOR; | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''P'' : |
| 8 24 24 | * //Returns:// ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]<[[playground/playground#Set |Set]]>>'' |
| 24 12 24 | * 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 |
| 24 24 6 | |
| </code> | |
| |
| {{anchor:MOEBIUS_STRIP_EDGES:}} **''MOEBIUS_STRIP_EDGES''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:stabbing_order:}} **''stabbing_order([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P)''** |
| * Ordered list of edges of a Moebius strip with parallel interior edges. \\ Consists of k lines of the form (v<sub>i</sub> w<sub>i</sub>), for i=1, ..., k. \\\\ The Moebius strip in question is given by the quadrangles \\ (v<sub>i</sub>, w<sub>i</sub>, w<sub>i+1</sub>,v<sub>i+1</sub>), for i=1, ..., k-1, and the quadrangle (v<sub>1</sub>, w<sub>1</sub>, v<sub>k</sub>, w<sub>k</sub>).\\\\ Validity can be verified with the client [[/polytope/functions/Consistency check/validate_moebius_strip]].\\ The polytope is required to be 2-cubical. | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''P'' : |
| | * //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 |
| |
| {{anchor:EDGE_ORIENTABLE:}} **''EDGE_ORIENTABLE''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:stanley_reisner:}} **''stanley_reisner([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * True if there exists an edge-orientation (see [[/polytope/objects/Polytope/properties/Combinatorics/EDGE_ORIENTATION]] for a definition).\\ The polytope is required to be 2-cubical. | * //Parameters:// |
| * //Example://\\ The following checks a 3-dimensional cube for edge orientability: \\ <code> > $p = cube(3); | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $p->EDGE_ORIENTABLE; | * //Returns:// ''[[playground/playground/Ideal# |Ideal]]'' |
| true | * Creates the __Stanley-Reisner ideal__ of a simplicial complex. |
| </code> | |
| * //Example://\\ A 3-dimensinal cube with one stacked facet is still 2-cubical. Therefore we can check for edge orientability: \\ <code> > $p = stack(cube(3),5); | |
| print $p->EDGE_ORIENTABLE; | |
| true | |
| </code> | |
| |
| {{anchor:N_VERTICES:}} **''N_VERTICES''** | \\ |
| * //Type:// [[common:Basic Types#Int | Int]] | {{anchor:is_generalized_shelling:}} **''is_generalized_shelling([[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]> FaceList)''** |
| * Number of [[/polytope/objects/Polytope/properties/Geometry/VERTICES]].\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/N_RAYS]]. | * //Parameters:// |
| * //Example://\\ The following prints the number of vertices of a 3-dimensional cube: \\ <code> > print cube(3)->N_VERTICES; | * ''[[playground/playground#Array |Array]]<[[playground/playground#Set |Set]]>'' ''FaceList'' : |
| 8 | * //Returns:// ''[[playground/playground#Bool |Bool]]'' |
| </code> | * Check if a given sequence of faces of a simplicial complex is a generalized shelling. |
| * //Example://\\ The following prints the number of vertices of the convex hull of 10 specific points lying in the unit square [0,1]^2: \\ <code> > print rand_box(2,10,1,seed=>4583572)->N_VERTICES; | |
| 4 | |
| </code> | |
| |
| {{anchor:SIMPLICIALITY:}} **''SIMPLICIALITY''** | \\ |
| * //Type:// [[common:Basic Types#Int | Int]] | {{anchor:persistent_homology:}} **''persistent_homology''** |
| * Maximal dimension in which all faces are simplices. | |
| * //Example://\\ The 3-dimensional cross-polytope is simplicial, i.e. its simplicity is 2. After truncating an arbitrary vertex\\ the simplicity is reduced to 1. \\ <code> > print cross(3)->SIMPLICIALITY; | |
| 2 | |
| </code>\\ \\ <code> > print truncation(cross(3),4)->SIMPLICIALITY; | |
| 1 | |
| </code> | |
| |
| {{anchor:FOLDABLE_MAX_SIGNATURE_UPPER_BOUND:}} **''FOLDABLE_MAX_SIGNATURE_UPPER_BOUND''** | \\ |
| * //Type:// [[common:Basic Types#Int | Int]] | {{anchor:random_discrete_morse:}} **''random_discrete_morse([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * An upper bound for the maximal signature of a foldable triangulation of a polytope\\ The signature is the absolute difference of the normalized volumes of black minus white maximal simplices,\\ where only odd normalized volumes are taken into account. | * //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) |
| |
| {{anchor:SIMPLE:}} **''SIMPLE''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{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)''** |
| * True if the polytope is simple. Dual to [[/polytope/objects/Polytope/properties/Combinatorics/SIMPLICIAL]]. | * //Template Parameters:// |
| * //Example://\\ This determines if a 3-dimensional cube is simple or not: \\ <code> > print cube(3)->SIMPLE; | * ''Coeff'' : desired coefficient type of the filtration |
| true | * //Parameters:// |
| </code> | * ''[[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 |
| {{anchor:SELF_DUAL:}} **''SELF_DUAL''** | * ''[[playground/playground#Float |Float]]'' ''step_size'' : |
| * //Type:// [[common:Basic Types#Bool | Bool]] | * ''[[playground/playground#Int |Int]]'' ''k'' : dimension of the resulting filtration |
| * True if the polytope is self-dual. | * //Returns:// ''[[playground/playground#Filtration |Filtration]]<[[playground/playground#SparseMatrix |SparseMatrix]]<[[playground/playground#vietoris |vietoris]]'' |
| * //Example://\\ The following checks if the centered square with side length 2 is self dual: \\ <code> > print cube(2)->SELF_DUAL; | * 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. |
| true | |
| </code> | |
| * //Example://\\ The elongated square pyramid (Johnson solid 8) is dual to itself, since the apex of the square pyramid attachted to the cube\\ and the opposing square of the cube swap roles. The following checks this property and prints the result: \\ <code> > print johnson_solid(8)->SELF_DUAL; | |
| true | |
| </code> | |
| | |
| {{anchor:COCUBICALITY:}} **''COCUBICALITY''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Dual to [[/polytope/objects/Polytope/properties/Combinatorics/CUBICALITY]]. | |
| * //Example://\\ After stacking a facet of the 3-dimensional cube, its cubicality is lowered to 2. Hence its dual polytope has cocubicality 2 as well. The\\ following produces such a stacked cube and asks for its cocubicality after polarization: \\ <code> > $p = stack(cube(3),5); | |
| print polarize($p)->COCUBICALITY; | |
| 2 | |
| </code> | |
| | |
| {{anchor:EXCESS_VERTEX_DEGREE:}} **''EXCESS_VERTEX_DEGREE''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Measures the deviation of the cone from being simple in terms of the [[/polytope/objects/Polytope/properties/Combinatorics/GRAPH]].\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/EXCESS_RAY_DEGREE]]. | |
| * //Example://\\ The excess vertex degree of an egyptian pyramid is one. \\ <code> > print pyramid(cube(2))->EXCESS_VERTEX_DEGREE; | |
| 1 | |
| </code> | |
| | |
| {{anchor:CD_INDEX_COEFFICIENTS:}} **''CD_INDEX_COEFFICIENTS''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * Coefficients of the cd-index. | |
| | |
| {{anchor:FATNESS:}} **''FATNESS''** | |
| * //Type:// [[common:Basic Types#Float | Float]] | |
| * Parameter describing the shape of the face-lattice of a 4-polytope. | |
| | |
| {{anchor:TWO_FACE_SIZES:}} **''TWO_FACE_SIZES''** | |
| * //Type:// [[common:Set Types#Map | Map]] | |
| * Lists for each occurring size (= number of incident vertices or edges) of a 2-face how many there are. | |
| * //Example://\\ This prints the number of facets spanned by 3,4 or 5 vertices a truncated 3-dimensional cube has. \\ <code> > $p = truncation(cube(3),5); | |
| print $p->TWO_FACE_SIZES; | |
| {(3 1) (4 3) (5 3)} | |
| </code> | |
| | |
| {{anchor:BALANCE:}} **''BALANCE''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Maximal dimension in which all facets are balanced. | |
| * //Example://\\ The following full dimensional polytope given by 10 specific vertices on the 8-dimensional sphere is 3-neighborly. Hence the dual polytope is\\ 3-balanced, where we first center and then polarize it. \\ <code> > $p = rand_sphere(8,10,seed=>8866463); | |
| $q = polarize(center($p)); | |
| print $q->BALANCE; | |
| 3 | |
| </code> | |
| | |
| {{anchor:SIMPLICITY:}} **''SIMPLICITY''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Maximal dimension in which all dual faces are simplices. | |
| * //Example://\\ This checks the 3-dimensional cube for simplicity. Since the cube is dual to the cross-polytope of equal dimension and all its faces are simplices,\\ the result is 2. \\ <code> > print cube(3)->SIMPLICITY; | |
| 2 | |
| </code> | |
| | |
| {{anchor:DUAL_BOUNDED_H_VECTOR:}} **''DUAL_BOUNDED_H_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * h-vector of the bounded subcomplex, defined for not necessarily bounded polyhedra\\ which are simple (as polyhedra, i.e., [[/polytope/objects/Cone/methods/Combinatorics/VERTEX_DEGREES]] on the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/FAR_FACE]] do not matter).\\ Coincides with the reverse h-vector of the dual simplicial ball.\\ Note that this vector will usually start with a number of zero entries. | |
| | |
| {{anchor:SUBRIDGE_SIZES:}} **''SUBRIDGE_SIZES''** | |
| * //Type:// [[common:Set Types#Map | Map]] | |
| * Lists for each occurring size (= number of incident facets or ridges) of a subridge how many there are. | |
| | |
| {{anchor:SIMPLEXITY_LOWER_BOUND:}} **''SIMPLEXITY_LOWER_BOUND''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * A lower bound for the minimal number of simplices in a triangulation | |
| | |
| {{anchor:VERTICES_IN_FACETS:}} **''VERTICES_IN_FACETS''** | |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | |
| * Vertex-facet incidence matrix, with rows corresponding to facets and columns\\ to vertices. Vertices and facets are numbered from 0 to [[/polytope/objects/Polytope/properties/Combinatorics/N_VERTICES]]-1 rsp.\\ [[/polytope/objects/Cone/properties/Geometry/N_FACETS]]-1, according to their order in [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] rsp. [[/polytope/objects/Cone/properties/Geometry/FACETS]].\\\\ This property is at the core of all combinatorial properties. It has the following semantics:\\ (1) The combinatorics of an unbounded and pointed polyhedron is defined to be the combinatorics\\ of the projective closure.\\ (2) The combiantorics of an unbounded polyhedron which is not pointed is defined to be the\\ combinatorics of the quotient modulo the lineality space.\\ Therefore: [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] and each other property which is grouped under "Combinatorics"\\ always refers to some polytope.\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_FACETS]]. | |
| * //Example://\\ The following prints the vertex-facet incidence matrix of a 5-gon by listing all facets as a set of contained vertices\\ in a cyclic order (each line corresponds to an edge): \\ <code> > print n_gon(5)->VERTICES_IN_FACETS; | |
| {1 2} | |
| {2 3} | |
| {3 4} | |
| {0 4} | |
| {0 1} | |
| </code> | |
| * //Example://\\ The following prints the Vertex_facet incidence matrix of the standard 3-simplex together with the facet numbers: \\ <code> > print rows_numbered(simplex(3)->VERTICES_IN_FACETS); | |
| 0:1 2 3 | |
| 1:0 2 3 | |
| 2:0 1 3 | |
| 3:0 1 2 | |
| </code> | |
| | |
| {{anchor:F_VECTOR:}} **''F_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * f<sub>k</sub> is the number of k-faces. | |
| * //Example://\\ This prints the f-vector of a 3-dimensional cube. The first entry represents the vertices. \\ <code> > print cube(3)->F_VECTOR; | |
| 8 12 6 | |
| </code> | |
| * //Example://\\ This prints the f-vector of the 3-dimensional cross-polytope. Since the cube and the cross polytope\\ of equal dimension are dual, their f-vectors are the same up to reversion. \\ <code> > print cross(3)->F_VECTOR; | |
| 6 12 8 | |
| </code> | |
| * //Example://\\ After truncating the first standard basis vector of the 3-dimensional cross-polytope the f-vector changes.\\ Only segments of the incident edges of the cut off vertex remain and the intersection of these with the new hyperplane\\ generate four new vertices. These also constitute four new edges and a new facet. \\ <code> > print truncation(cross(3),4)->F_VECTOR; | |
| 9 16 9 | |
| </code> | |
| | |
| {{anchor:SIMPLICIAL:}} **''SIMPLICIAL''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if the polytope is simplicial. | |
| * //Example://\\ A polytope with random vertices uniformly distributed on the unit sphere is simplicial. The following checks\\ this property and prints the result for 8 points in dimension 3: \\ <code> > print rand_sphere(3,8)->SIMPLICIAL; | |
| true | |
| </code> | |
| | |
| {{anchor:ALTSHULER_DET:}} **''ALTSHULER_DET''** | |
| * //Type:// [[common:Basic Types#Integer | Integer]] | |
| * Let M be the vertex-facet incidence matrix, then the Altshuler determinant is\\ defined as max{det(M ∗ M<sup>T</sup>), det(M<sup>T</sup> ∗ M)}. | |
| * //Example://\\ This prints the Altshuler determinant of the built-in pentagonal pyramid (Johnson solid 2): \\ <code> > print johnson_solid("pentagonal_pyramid")->ALTSHULER_DET; | |
| 25 | |
| </code> | |
| | |
| {{anchor:HASSE_DIAGRAM:}} **''HASSE_DIAGRAM''** | |
| * //Type:// [[graph/Lattice | Lattice]] | |
| | |
| {{anchor:FACETS_THRU_VERTICES:}} **''FACETS_THRU_VERTICES''** | |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | |
| * transposed [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]]\\ Notice that this is a temporary property; it will not be stored in any file.\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/FACETS_THRU_RAYS]]. | |
| | |
| {{anchor:FACE_SIMPLICITY:}} **''FACE_SIMPLICITY''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Maximal dimension in which all faces are simple polytopes.\\ This checks the 3-dimensional cube for face simplicity. Since the cube is dual to the cross-polytope of equal dimension and it is simplicial,\\ the result is 3.\\ > print cube(3)->SIMPLICITY;\\ | 3 | |
| | |
| {{anchor:NEIGHBORLINESS:}} **''NEIGHBORLINESS''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Maximal dimension in which all facets are neighborly. | |
| * //Example://\\ This determines that the full dimensional polytope given by 10 specific vertices on the 8-dimensional sphere is 3-neighborly, i.e.\\ all 3-dimensional faces are tetrahedra. Hence the polytope is not neighborly. \\ <code> > print rand_sphere(8,10,seed=>8866463)->NEIGHBORLINESS; | |
| 3 | |
| </code> | |
| | |
| {{anchor:VERTEX_SIZES:}} **''VERTEX_SIZES''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Number of incident facets for each vertex.\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/RAY_SIZES]]. | |
| * //Example://\\ The following prints the number of incident facets for each vertex of the elongated pentagonal pyramid (Johnson solid 9) \\ <code> > print johnson_solid(9)->VERTEX_SIZES; | |
| 5 4 4 4 4 4 3 3 3 3 3 | |
| </code> | |
| | |
| {{anchor:DUAL_H_VECTOR:}} **''DUAL_H_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * dual h-vector, defined via recursion on the face lattice of a polytope.\\ Coincides for simple polytopes with the combinatorial definition\\ of the h-vector via abstract objective functions. | |
| | |
| {{anchor:N_VERTEX_FACET_INC:}} **''N_VERTEX_FACET_INC''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Number of pairs of incident vertices and facets.\\ Alias for property [[/polytope/objects/Cone/properties/Combinatorics/N_RAY_FACET_INC]]. | |
| | |
| {{anchor:NEIGHBORLY:}} **''NEIGHBORLY''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if the polytope is neighborly. | |
| * //Example://\\ This checks the 4-dimensional cyclic polytope with 6 points on the moment curve for neighborliness, i.e. if it is ⌊dim/2⌋ neighborly: \\ <code> > print cyclic(4,6)->NEIGHBORLY; | |
| true | |
| </code> | |
| | |
| {{anchor:BALANCED:}} **''BALANCED''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * Dual to [[/polytope/objects/Polytope/properties/Combinatorics/NEIGHBORLY]]. | |
| * //Example://\\ Since cyclic polytopes generated by vertices on the moment curve are neighborly, their dual polytopes are balanced. The following checks this\\ for the 4-dimensional case by centering the cyclic polytope and then polarizing it: \\ <code> > $p = cyclic(4,6); | |
| $q = polarize(center($p)); | |
| print $q->BALANCED; | |
| true | |
| </code> | |
| | |
| {{anchor:CUBICAL_H_VECTOR:}} **''CUBICAL_H_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * Cubical h-vector. Defined for cubical polytopes. | |
| | |
| {{anchor:CUBICALITY:}} **''CUBICALITY''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Maximal dimension in which all facets are cubes. | |
| * //Example://\\ We will modify the 3-dimensional cube in two different ways. While stacking some facets (in this case facets 4 and 5) preserves the cubicality up to\\ dimension 2, truncating an arbitrary vertex reduces the cubicality to 1. \\ <code> > print stack(cube(3),[4,5])->CUBICALITY; | |
| 2 | |
| </code>\\ \\ <code> > print truncation(cube(3),5)->CUBICALITY; | |
| 1 | |
| </code> | |
| | |
| {{anchor:MOEBIUS_STRIP_QUADS:}} **''MOEBIUS_STRIP_QUADS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * Unordered list of quads which forms a Moebius strip with parallel interior edges.\\ Each line lists the vertices of a quadrangle in cyclic order.\\\\ Validity can be verified with the client [[/polytope/functions/Consistency check/validate_moebius_strip_quads]].\\ The polytope is required to be 2-cubical. | |
| |
| ---- | ---- |
| ==== Geometry ==== | ==== Producing a new simplicial complex from others ==== |
| These properties capture geometric information of the object. Geometric properties depend on geometric information of the object, like, e.g., vertices or facets. | These functions construct a new [[/topaz/objects/SimplicialComplex]] from other objects of the same type. |
| {{anchor:CENTRALLY_SYMMETRIC:}} **''CENTRALLY_SYMMETRIC''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:star_deletion:}} **''star_deletion([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| * True if P = -P. | * //Parameters:// |
| * //Example://\\ A centered 3-cube is centrally symmetric. By stacking a single facet (5), this property is lost. We can\\ recover it by stacking the opposing facet (4) as well. \\ <code> > $p = cube(3); | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $p->CENTRALLY_SYMMETRIC; | * ''[[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. |
| true | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| </code>\\ \\ <code> > print stack($p,5)->CENTRALLY_SYMMETRIC; | * Remove the star of a given //face//. |
| false | |
| </code>\\ \\ <code> > print stack($p,new Set<Int>(4,5))->CENTRALLY_SYMMETRIC; | |
| true | |
| </code> | |
| |
| {{anchor:ONE_VERTEX:}} **''ONE_VERTEX''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:bistellar_simplification:}} **''bistellar_simplification([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * A vertex of a pointed polyhedron.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/ONE_RAY]]. | * //Parameters:// |
| * //Example://\\ This prints the first vertex of the 3-cube (corresponding to the first row in the vertex matrix). \\ <code> > print cube(3)->ONE_VERTEX; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| 1 -1 -1 -1 | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| </code> | * 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. |
| |
| {{anchor:INEQUALITIES_THRU_VERTICES:}} **''INEQUALITIES_THRU_VERTICES''** | \\ |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | {{anchor:simplicial_product:}} **''simplicial_product''** |
| * transposed [[/polytope/objects/Polytope/properties/Geometry/VERTICES_IN_INEQUALITIES]]\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/INEQUALITIES_THRU_RAYS]]. | |
| |
| {{anchor:VERTICES:}} **''VERTICES''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{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)''** |
| * Vertices of the polyhedron. No redundancies are allowed.\\ All vectors in this section must be non-zero.\\ The coordinates are normalized the same way as [[/polytope/objects/Polytope/properties/Input property/POINTS]]. Dual to [[/polytope/objects/Cone/properties/Geometry/FACETS]].\\ This section is empty if and only if the polytope is empty.\\ The property [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] appears only in conjunction with the property [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]].\\ The specification of the property [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] requires the specification of [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]], and vice versa.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/RAYS]]. | * //Parameters:// |
| * //Example://\\ To print the vertices (in homogeneous coordinates) of the standard 2-simplex, i.e. a right-angled isoceles triangle, type this: \\ <code> > print simplex(2)->VERTICES; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| (3) (0 1) | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| 1 1 0 | * ''[[playground/playground#Int |Int]]'' ''f1'' : default: 0 |
| 1 0 1 | * ''[[playground/playground#Int |Int]]'' ''f2'' : default: 0 |
| </code> | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * //Example://\\ If we know some points to be vertices of their convex hull, we can store them as rows in a Matrix and construct a new polytope with it.\\ The following produces a 3-dimensioanl pyramid over the standard 2-simplex with the specified vertices: \\ <code> > $M = new Matrix([[1,0,0,0],[1,1,0,0],[1,0,1,0],[1,0,0,3]]); | * 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. |
| $p = new Polytope(VERTICES=>$M); | * //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]); |
| </code> | > print $cs->SURFACE.','.$cs->GENUS; |
| * //Example://\\ The following adds a (square) pyramid to one facet of a 3-cube. We do this by extracting the vertices of the cube via the built-in\\ method and then attach the apex of the pyramid to the matrix. \\ <code> > $v = new Vector([1,0,0,3/2]); | 1,2 |
| $M = cube(3)->VERTICES / $v; | |
| $p = new Polytope(VERTICES=>$M); | |
| </code> | </code> |
| |
| {{anchor:STEINER_POINTS:}} **''STEINER_POINTS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:triang_neighborhood:}} **''triang_neighborhood([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Rational |Rational]] width)''** |
| * A weighted inner point depending on the outer angle called Steiner point for all faces of dimensions 2 to d. | * //Parameters:// |
| | * ''[[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. |
| |
| {{anchor:POINTS_IN_FACETS:}} **''POINTS_IN_FACETS''** | \\ |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | {{anchor:hom_poset:}} **''hom_poset''** |
| * Similar to [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]], but with columns corresponding to [[/polytope/objects/Polytope/properties/Input property/POINTS]] instead of [[/polytope/objects/Polytope/properties/Geometry/VERTICES]].\\ This property is a byproduct of convex hull computation algorithms.\\ It is discarded as soon as [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] is computed.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/INPUT_RAYS_IN_FACETS]]. | |
| |
| {{anchor:SPLIT_COMPATIBILITY_GRAPH:}} **''SPLIT_COMPATIBILITY_GRAPH''** | \\ |
| * //Type:// [[graph/Graph | Graph]] | {{anchor:covering_relations:}} **''covering_relations([[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> P)''** |
| * Two [[/polytope/objects/Polytope/properties/Geometry/SPLITS]] are compatible if the defining hyperplanes do not intersect in the\\ interior of the polytope. This defines a graph. | * //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 |
| |
| {{anchor:N_POINTS:}} **''N_POINTS''** | \\ |
| * //Type:// [[common:Basic Types#Int | Int]] | {{anchor:h_induced_quotient:}} **''h_induced_quotient([[playground/playground/SimplicialComplex# |SimplicialComplex]] C, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> vertices)''** |
| * Number of [[/polytope/objects/Polytope/properties/Input property/POINTS]].\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/N_INPUT_RAYS]]. | * //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//. |
| |
| {{anchor:QUOTIENT_SPACE:}} **''QUOTIENT_SPACE''** | \\ |
| * //Type:// [[polytope/QuotientSpace | QuotientSpace]] | {{anchor:sum_triangulation:}} **''sum_triangulation([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] P, [[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] Q, [[playground/playground#IncidenceMatrix |IncidenceMatrix]] WebOfStars)''** |
| * A topological quotient space obtained from a polytope by identifying faces. | * //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 |
| |
| {{anchor:FACETS_THRU_POINTS:}} **''FACETS_THRU_POINTS''** | \\ |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | {{anchor:induced_subcomplex:}} **''induced_subcomplex([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> vertices)''** |
| * similar to [[/polytope/objects/Polytope/properties/Combinatorics/FACETS_THRU_VERTICES]], but with [[/polytope/objects/Polytope/properties/Input property/POINTS]] instead of [[/polytope/objects/Polytope/properties/Geometry/VERTICES]]\\ Notice that this is a temporary property; it will not be stored in any file.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/FACETS_THRU_INPUT_RAYS]]. | * //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//. |
| |
| {{anchor:FEASIBLE:}} **''FEASIBLE''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:foldable_prism:}} **''foldable_prism([[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]] complex)''** |
| * True if the polyhedron is not empty. | * //Parameters:// |
| | * ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' ''complex'' : |
| | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| | * Produce a __prism__ over a given ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]''. |
| |
| {{anchor:GALE_TRANSFORM:}} **''GALE_TRANSFORM''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:edge_contraction:}} **''edge_contraction([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * Coordinates of the Gale transform. | * //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. |
| |
| {{anchor:VERTEX_BARYCENTER:}} **''VERTEX_BARYCENTER''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:disjoint_union:}} **''disjoint_union([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| * The center of gravity of the vertices of a bounded polytope. | * //Parameters:// |
| * //Example://\\ This prints the vertex barycenter of the standard 3-simplex: \\ <code> > print simplex(3)->VERTEX_BARYCENTER; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| 1 1/4 1/4 1/4 | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| </code> | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Produce the __disjoint union__ of the two given complexes. |
| |
| {{anchor:CONE_DIM:}} **''CONE_DIM''** | \\ |
| * //Type:// [[common:Basic Types#Int | Int]] | {{anchor:stellar_subdivision:}} **''stellar_subdivision''** |
| * One more than the dimension of the affine hull of the polyhedron\\ = one more than the dimension of the polyhedron.\\ = dimension of the homogenization of the polyhedron\\ If the polytope is given purely combinatorially, this is the dimension of a minimal embedding space | |
| * //Example://\\ This prints the cone dimension of a 3-cube. Since the dimension of its affine closure is 3, the result is 4. \\ <code> > print cube(3)->CONE_DIM; | |
| 4 | |
| </code> | |
| |
| {{anchor:SPLITS:}} **''SPLITS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{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)''** |
| * The splits of the polytope, i.e., hyperplanes cutting the polytope in\\ two parts such that we have a regular subdivision. | * //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. |
| |
| {{anchor:LATTICE:}} **''LATTICE''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:barycentric_subdivision:}} **''barycentric_subdivision([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * A rational polytope is lattice if each bounded vertex has integer coordinates. | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| {{anchor:CS_PERMUTATION:}} **''CS_PERMUTATION''** | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * //Type:// [[common:Basic Types#Array | Array]] | * Computes the __barycentric subdivision__ of //complex//. |
| * The permutation induced by the central symmetry, if present. | * //Example://\\ To subdivide a triangle into six new triangles, do this: \\ <code> > $b = barycentric_subdivision(simplex(2)); |
| | |
| {{anchor:CENTERED_ZONOTOPE:}} **''CENTERED_ZONOTOPE''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * is the zonotope calculated from ZONOTOPE_INPUT_POINTS or ZONOTOPE_INPUT_VECTORS to be centered at the origin?\\ The zonotope is always calculated as the Minkowski sum of all segments conv {x,v}, where\\ * v ranges over the ZONOTOPE_INPUT_POINTS or ZONOTOPE_INPUT_VECTORS, and\\ * x = -v if CENTERED_ZONOTOPE = 1,\\ * x = 0 if CENTERED_ZONOTOPE = 0.\\ Input section only. | |
| | |
| {{anchor:MINKOWSKI_CONE:}} **''MINKOWSKI_CONE''** | |
| * //Type:// [[polytope/Cone | Cone]] | |
| * The cone of all Minkowski summands of the polytope P.\\ Up to scaling, a polytope S is a Minkowski summand of P if and only if \\ the edge directions of S are a subset of those of P, \\ and the closing condition around any 2-face of P is preserved. \\ Coordinates of the cone correspond to the rescaled lengths \\ of the edges of the graph of P (in the order given by the property [[/graph/objects/Combinatorics/Graph/methods/Combinatorics/EDGES]] of the [[/polytope/objects/Cone/properties/Combinatorics/GRAPH]] of P). \\ The Minkowski cone is defined as the intersection of all \\ equations given by the closing condition around 2-faces with the positive orthant.\\ For more information see e.g. \\ Klaus Altmann: The versal deformation of an isolated toric Gorenstein singularity | |
| | |
| {{anchor:BOUNDED:}} **''BOUNDED''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if and only if [[/polytope/objects/Cone/properties/Geometry/LINEALITY_SPACE]] trivial and [[/polytope/objects/Polytope/properties/Unbounded polyhedra/FAR_FACE]] is trivial. | |
| * //Example://\\ A pyramid over a square is bounded. Removing the base square yields an unbounded pointed polyhedron\\ (the vertices with first entry equal to zero correspond to rays). \\ <code> > $p = pyramid(cube(2)); | |
| print $p->BOUNDED; | |
| true | |
| </code>\\ \\ <code> > $q = facet_to_infinity($p,4); | |
| print $q->BOUNDED; | |
| false | |
| </code> | </code> |
| |
| {{anchor:ZONOTOPE_INPUT_POINTS:}} **''ZONOTOPE_INPUT_POINTS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:union:}} **''union([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| * The rows of this matrix contain a configuration of affine points in homogeneous cooordinates.\\ The zonotope is obtained as the Minkowski sum of all rows, normalized to x_0 = 1.\\ Thus, if the input matrix has n columns, the ambient affine dimension of the resulting zonotope is n-1. | * //Parameters:// |
| | * ''[[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. |
| |
| {{anchor:AFFINE_HULL:}} **''AFFINE_HULL''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:cone:}} **''cone([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| * Dual basis of the affine hull of the polyhedron.\\ The property [[/polytope/objects/Polytope/properties/Geometry/AFFINE_HULL]] 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/Polytope/properties/Geometry/AFFINE_HULL]], and vice versa.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/LINEAR_SPAN]]. | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| {{anchor:VERTICES_IN_RIDGES:}} **''VERTICES_IN_RIDGES''** | * ''[[playground/playground#Int |Int]]'' ''k'' : default is 1 |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * Alias for property [[/polytope/objects/Cone/properties/Combinatorics/RAYS_IN_RIDGES]]. | * Produce the //k//-cone over a given simplicial complex. |
| | * //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']); |
| {{anchor:CONE_AMBIENT_DIM:}} **''CONE_AMBIENT_DIM''** | > print $c->FACETS; |
| * //Type:// [[common:Basic Types#Int | Int]] | {0 1 2 3 4} |
| * One more than the dimension of the space in which the polyhedron lives.\\ = dimension of the space in which the homogenization of the polyhedron lives | </code>\\ \\ <code> > print $c->VERTEX_LABELS; |
| | 0 1 2 foo bar |
| {{anchor:VERTEX_NORMALS:}} **''VERTEX_NORMALS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | 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.\\ All vectors in this section must be non-zero.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/RAY_SEPARATORS]]. | |
| * //Example://\\ This prints a matrix in which each row represents a normal vector of a hyperplane seperating one vertex of a centered square\\ with side length 2 from the other ones. The first and the last hyperplanes as well as the second and third hyperplanes are the same\\ up to orientation. \\ <code> > print cube(2)->VERTEX_NORMALS; | |
| 0 1/2 1/2 | |
| 0 -1/2 1/2 | |
| 0 1/2 -1/2 | |
| 0 -1/2 -1/2 | |
| </code> | </code> |
| |
| {{anchor:STEINER_POINT:}} **''STEINER_POINT''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:join_complexes:}} **''join_complexes([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex1, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex2)''** |
| * Steiner point of the whole polytope. | * //Parameters:// |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex1'' : |
| | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex2'' : |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * Creates the join of //complex1// and //complex2//. |
| |
| {{anchor:TILING_LATTICE:}} **''TILING_LATTICE''** | \\ |
| * //Type:// [[polytope/AffineLattice | AffineLattice]] | {{anchor:alexander_dual:}} **''alexander_dual([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * An affine lattice L such that P + L tiles the affine span of P | * //Parameters:// |
| | * ''[[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. |
| |
| {{anchor:VERTICES_IN_INEQUALITIES:}} **''VERTICES_IN_INEQUALITIES''** | \\ |
| * //Type:// [[common:Set Types#IncidenceMatrix | IncidenceMatrix]] | {{anchor:deletion:}} **''deletion([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| * Similar to [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]], but with rows corresponding to [[/polytope/objects/Polytope/properties/Input property/INEQUALITIES]] instead of [[/polytope/objects/Cone/properties/Geometry/FACETS]].\\ This property is a byproduct of convex hull computation algorithms.\\ It is discarded as soon as [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] is computed.\\ Alias for property [[/polytope/objects/Cone/properties/Geometry/RAYS_IN_INEQUALITIES]]. | * //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. |
| |
| {{anchor:VALID_POINT:}} **''VALID_POINT''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:link_complex:}} **''link_complex([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| * Some point belonging to the polyhedron. | * //Parameters:// |
| * //Example://\\ This stores a (homogeneous) point belonging to the 3-cube as a vector and prints its coordinates: \\ <code> > $v = cube(3)->VALID_POINT; | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $v; | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : |
| 1 -1 -1 -1 | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| </code> | * Produce the __link__ of a //face// of the //complex// |
| |
| {{anchor:WEAKLY_CENTERED:}} **''WEAKLY_CENTERED''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:star:}} **''star([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]> face)''** |
| * True if (1, 0, 0, ...) is contained (possibly in the boundary). | * //Parameters:// |
| * //Example://\\ The cube [0,1]^3 is only weakly centered, since the origin is on the boundary. \\ <code> > $p = cube(3,0,0); | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $p->WEAKLY_CENTERED; | * ''[[playground/playground#Set |Set]]<[[playground/playground#Int |Int]]>'' ''face'' : |
| true | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| </code>\\ \\ <code> > print $p->CENTERED; | * Produce the __star__ of the //face// of the //complex//. |
| false | |
| </code> | |
| |
| {{anchor:FAR_HYPERPLANE:}} **''FAR_HYPERPLANE''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:colored_ball_from_colored_sphere:}} **''colored_ball_from_colored_sphere([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * Valid strict inequality for all affine points of the polyhedron. | * //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. |
| |
| {{anchor:CENTROID:}} **''CENTROID''** | \\ |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | {{anchor:poset_homomorphisms:}} **''poset_homomorphisms([[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> P, [[playground/playground/Graph# |Graph]]<[[playground/playground#Directed |Directed]]> Q)''** |
| * Centroid (center of mass) of the polytope. | * //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 |
| |
| {{anchor:POINTED:}} **''POINTED''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:iterated_barycentric_subdivision:}} **''iterated_barycentric_subdivision([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| * True if the polyhedron does not contain an affine line. | * //Parameters:// |
| * //Example://\\ A square does not contain an affine line and is therefore pointed. Removing one facet does not change this, although\\ it is no longer bounded. After removing two opposing facets, it contains infinitely many affine lines orthogonal to the\\ removed facets. \\ <code> > $p = cube(2); | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : |
| print $p->POINTED; | * ''[[playground/playground#Int |Int]]'' ''k'' : |
| true | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| </code>\\ \\ <code> > print facet_to_infinity($p,0)->POINTED; | * Computes the //k//-th __barycentric subdivision__ of //complex// by iteratively calling ''[[playground/playground#barycentric |barycentric]]''. |
| true | |
| </code>\\ \\ <code> > print new Polytope(INEQUALITIES=>$p->FACETS->minor([0,1],All))->POINTED; | |
| false | |
| </code> | |
| |
| {{anchor:CENTERED:}} **''CENTERED''** | \\ |
| * //Type:// [[common:Basic Types#Bool | Bool]] | {{anchor:k_skeleton:}} **''k_skeleton''** |
| * True if (1, 0, 0, ...) is in the relative interior.\\ If full-dimensional then polar to [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]]. | |
| * //Example://\\ The cube [0,1]^3 is not centered, since the origin is on the boundary. By a small translation we can make it centered: \\ <code> > $p = cube(3,0,0); | |
| print $p->CENTERED; | |
| false | |
| </code>\\ \\ <code> > $t = new Vector([-1/2,-1/2,-1/2]); | |
| print translate($p,$t)->CENTERED; | |
| true | |
| </code> | |
| |
| {{anchor:MINIMAL_VERTEX_ANGLE:}} **''MINIMAL_VERTEX_ANGLE''** | \\ |
| * //Type:// [[common:Basic Types#Float | Float]] | {{anchor:suspension:}} **''suspension([[playground/playground/SimplicialComplex# |SimplicialComplex]] complex, [[playground/playground#Int |Int]] k)''** |
| * The minimal angle between any two vertices (seen from the [[/polytope/objects/Polytope/properties/Geometry/VERTEX_BARYCENTER]]). | * //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. |
| |
| {{anchor:SPECIAL_FACETS:}} **''SPECIAL_FACETS''** | \\ |
| * //Type:// [[common:Set Types#Set | Set]] | {{anchor:bs2quotient:}} **''bs2quotient([[playground/playground/Polytope# |Polytope]] P, [[playground/playground/SimplicialComplex# |SimplicialComplex]] complex)''** |
| * The following is defined for [[/polytope/objects/Polytope/properties/Geometry/CENTERED]] polytopes only:\\ A facet is special if the cone over that facet with the origin as the apex contains the [[/polytope/objects/Polytope/properties/Geometry/VERTEX_BARYCENTER]].\\ Motivated by Obro's work on Fano polytopes. | * //Parameters:// |
| | * ''[[playground/playground/Polytope# |Polytope]]'' ''P'' : the underlying polytope |
| {{anchor:N_01POINTS:}} **''N_01POINTS''** | * ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' ''complex'' : a sufficiently fine subdivision of P, for example the second barycentric subdivision |
| * //Type:// [[common:Basic Types#Int | Int]] | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * Number of points with 0/1-coordinates in a polytope. | * 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. |
| |
| ---- | ---- |
| ==== Input property ==== | ==== Producing a simplicial complex from other objects ==== |
| These properties are for input only. They allow redundant information. | These functions construct a new [[/topaz/objects/SimplicialComplex]] from other objects. |
| {{anchor:INEQUALITIES:}} **''INEQUALITIES''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:vietoris_rips_complex:}} **''vietoris_rips_complex([[playground/playground#Matrix |Matrix]] D, [[playground/playground#Rational |Rational]] delta)''** |
| * Inequalities that describe half-spaces such that the polyhedron is their intersection.\\ Redundancies are allowed. Dual to [[/polytope/objects/Polytope/properties/Input property/POINTS]].\\\\ A vector (A<sub>0</sub>, A<sub>1</sub>, ..., A<sub>d</sub>) defines the\\ (closed affine) half-space of points (1, x<sub>1</sub>, ..., x<sub>d</sub>) such that\\ A<sub>0</sub> + A<sub>1</sub> x<sub>1</sub> + ... + A<sub>d</sub> x<sub>d</sub> >= 0.\\\\ Input section only. Ask for [[/polytope/objects/Cone/properties/Geometry/FACETS]] and [[/polytope/objects/Polytope/properties/Geometry/AFFINE_HULL]] if you want to compute an H-representation\\ from a V-representation. | * //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. |
| |
| {{anchor:POINTS:}} **''POINTS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:independence_complex:}} **''independence_complex([[playground/playground/Matroid# |Matroid]] matroid)''** |
| * Points such that the polyhedron is their convex hull.\\ Redundancies are allowed.\\ The vector (x<sub>0</sub>, x<sub>1</sub>, ... x<sub>d</sub>) represents a point in d-space given in homogeneous coordinates.\\ Affine points are identified by x<sub>0</sub> > 0.\\ Points with x<sub>0</sub> = 0 can be interpreted as rays.\\\\ polymake automatically normalizes each coordinate vector, dividing them by the first non-zero element.\\ The clients and rule subroutines can always assume that x<sub>0</sub> is either 0 or 1.\\ All vectors in this section must be non-zero.\\ Dual to [[/polytope/objects/Polytope/properties/Input property/INEQUALITIES]].\\\\ Input section only. Ask for [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] if you want to compute a V-representation from an H-representation.\\ Alias for property [[/polytope/objects/Cone/properties/Input property/INPUT_RAYS]]. | * //Parameters:// |
| * //Example://\\ Given some (homogeneous) points in 3-space we first construct a matrix containing them. Assume we don't know wether these are all\\ vertices of their convex hull or not. To safely produce a polytope from these points, we set the input to the matrix representing them.\\ In the following the points under consideration are the vertices of the 3-simplex together with their barycenter, which will be no vertex: \\ <code> > $M = new Matrix([[1,0,0,0],[1,1,0,0],[1,0,1,0],[1,0,0,1],[1,1/4,1/4,1/4]]); | * ''[[playground/playground/Matroid# |Matroid]]'' ''matroid'' : |
| $p = new Polytope(POINTS=>$M); | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| print $p->VERTICES; | * Produce the __independence complex__ of a given matroid.\\ If //no_labels// is set to 1, the labels are not copied. |
| 1 0 0 0 | |
| 1 1 0 0 | |
| 1 0 1 0 | |
| 1 0 0 1 | |
| </code> | |
| |
| {{anchor:EQUATIONS:}} **''EQUATIONS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:clique_complex:}} **''clique_complex([[playground/playground/Graph# |Graph]] graph)''** |
| * Equations that hold for all points of the polyhedron.\\\\ A vector (A<sub>0</sub>, A<sub>1</sub>, ..., A<sub>d</sub>) describes the hyperplane\\ of all points (1, x<sub>1</sub>, ..., x<sub>d</sub>) such that A<sub>0</sub> + A<sub>1</sub> x<sub>1</sub> + ... + A<sub>d</sub> x<sub>d</sub> = 0.\\ All vectors in this section must be non-zero.\\\\ Input section only. Ask for [[/polytope/objects/Polytope/properties/Geometry/AFFINE_HULL]] if you want to see an irredundant description of the affine span. | * //Parameters:// |
| | * ''[[playground/playground/Graph# |Graph]]'' ''graph'' : |
| ---- | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| ==== Lattice points in cones ==== | * 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. |
| These properties capture information that depends on the lattice structure of the cone. polymake always works with the integer lattice. | * //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]]); |
| {{anchor:SPANNING:}} **''SPANNING''** | > $c = clique_complex($g,no_labels=>1); |
| * //Type:// [[common:Basic Types#Bool | Bool]] | > print $c->FACETS; |
| * The polytope is __spanning__ if the lattice points generate the lattice | {0 1 2} |
| | {2 3} |
| {{anchor:FACET_WIDTHS:}} **''FACET_WIDTHS''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * The integral width of the polytope with respect to each facet normal. | |
| | |
| {{anchor:COMPRESSED:}} **''COMPRESSED''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if the [[/polytope/objects/Polytope/properties/Lattice points in cones/FACET_WIDTH]] is one. | |
| | |
| {{anchor:GORENSTEIN_INDEX:}} **''GORENSTEIN_INDEX''** | |
| * //Type:// [[common:Basic Types#Integer | Integer]] | |
| * If the polytope is [[/polytope/objects/Polytope/properties/Lattice points in cones/GORENSTEIN]] then this is the multiple such that the polytope is [[/polytope/objects/Polytope/properties/Lattice points in cones/REFLEXIVE]]. | |
| | |
| {{anchor:CANONICAL:}} **''CANONICAL''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __canonical__ if there is exactly one interior lattice point. | |
| | |
| {{anchor:LATTICE_EMPTY:}} **''LATTICE_EMPTY''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if the polytope contains no lattice points other than the vertices. | |
| | |
| {{anchor:POLAR_SMOOTH:}} **''POLAR_SMOOTH''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The lattice polytope is __polar to smooth__ if it is [[/polytope/objects/Polytope/properties/Lattice points in cones/REFLEXIVE]] and the polar of the polytope (wrt to its interior point) is a [[/polytope/objects/Polytope/properties/Lattice points in cones/SMOOTH]] lattice polytope. | |
| | |
| {{anchor:REFLEXIVE:}} **''REFLEXIVE''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if the polytope and its dual have integral vertices. | |
| | |
| {{anchor:EHRHART_POLYNOMIAL:}} **''EHRHART_POLYNOMIAL''** | |
| * //Type:// [[common:Algebraic Types#UniPolynomial | UniPolynomial]] | |
| * The Ehrhart polynomial. | |
| | |
| {{anchor:LATTICE_VOLUME:}} **''LATTICE_VOLUME''** | |
| * //Type:// [[common:Basic Types#Integer | Integer]] | |
| * The normalized volume of the polytope. | |
| | |
| {{anchor:EHRHART_QUASI_POLYNOMIAL:}} **''EHRHART_QUASI_POLYNOMIAL''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * The Ehrhart quasi-polynomial of a rational polytope.\\ Coefficients are periodic functions of integral period. | |
| * //Example://\\ To obtain the Ehrhart quasi-polynomial of a scaled 2-dimensional cross polytope write: \\ <code> > $p=scale(cross(2),1/3); | |
| print join("\n",@{$p->EHRHART_QUASI_POLYNOMIAL}); | |
| 2/9*x^2 + 2/3*x + 1 | |
| 2/9*x^2 + 2/9*x + 5/9 | |
| 2/9*x^2 -2/9*x + 5/9 | |
| </code> | </code> |
| |
| {{anchor:NORMAL:}} **''NORMAL''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __normal__ if the Hilbert basis of the cone spanned by P x {1} is at height 1.\\ Equivalently points in integral dilates of P are postive integral sums of lattice points of P. | |
| |
| {{anchor:FACET_VERTEX_LATTICE_DISTANCES:}} **''FACET_VERTEX_LATTICE_DISTANCES''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * The entry (i,j) equals the lattice distance of vertex j from facet i. | |
| |
| {{anchor:SMOOTH:}} **''SMOOTH''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __smooth__ if the associated projective variety is smooth; the determinant of the edge directions is +/-1 at every vertex. | |
| |
| {{anchor:GROEBNER_BASIS:}} **''GROEBNER_BASIS''** | |
| * //Type:// [[polytope/GroebnerBasis | GroebnerBasis]] | |
| * The Groebner basis for the toric ideal associated to the lattice points in the polytope using any term order. | |
| |
| {{anchor:LATTICE_CODEGREE:}} **''LATTICE_CODEGREE''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * [[/polytope/objects/Cone/properties/Combinatorics/COMBINATORIAL_DIM]]+1-[[/polytope/objects/Polytope/properties/Lattice points in cones/LATTICE_DEGREE]] or the smallest integer k such that k*P has an interior lattice point. | |
| |
| {{anchor:LATTICE_WIDTH_DIRECTION:}} **''LATTICE_WIDTH_DIRECTION''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * One direction which realizes [[/polytope/objects/Polytope/properties/Lattice points in cones/LATTICE_WIDTH]] of the polytope. | |
| |
| {{anchor:TERMINAL:}} **''TERMINAL''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __terminal__ if there is exactly one interior lattice point and all other lattice points are vertices. | |
| |
| {{anchor:LATTICE_BASIS:}} **''LATTICE_BASIS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] are interpreted as coefficient vectors for this basis\\ given in affine form\\ assumed to the the standard basis if not explicitely specified. | |
| |
| {{anchor:LATTICE_WIDTH:}} **''LATTICE_WIDTH''** | |
| * //Type:// [[common:Basic Types#Integer | Integer]] | |
| * The minimal integral width of the polytope. | |
| |
| {{anchor:GORENSTEIN:}} **''GORENSTEIN''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __Gorenstein__ if a dilation of the polytope is [[/polytope/objects/Polytope/properties/Lattice points in cones/REFLEXIVE]] up to translation. | |
| |
| {{anchor:GORENSTEIN_VECTOR:}} **''GORENSTEIN_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * If the polytope is [[/polytope/objects/Polytope/properties/Lattice points in cones/GORENSTEIN]], then this is the unique interior lattice point\\ in the multiple of the polytope that is [[/polytope/objects/Polytope/properties/Lattice points in cones/REFLEXIVE]]. | |
| |
| {{anchor:LATTICE_DEGREE:}} **''LATTICE_DEGREE''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * The degree of the h*-polynomial or Ehrhart polynomial. | |
| |
| {{anchor:VERY_AMPLE:}} **''VERY_AMPLE''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * The polytope is __very ample__ if the Hilbert Basis of the cone spanned by the edge-directions of any vertex lies inside the polytope. | |
| |
| {{anchor:FACET_WIDTH:}} **''FACET_WIDTH''** | |
| * //Type:// [[common:Basic Types#Integer | Integer]] | |
| * The maximal integral width of the polytope with respect to the facet normals. | |
| |
| ---- | ---- |
| ==== Lattice points in polytopes ==== | ==== Producing from scratch ==== |
| These properties capture information that depends on the lattice structure of the polytope. polymake always works with the integer lattice. | With these clients you can create special examples of simplicial complexes and complexes belonging to parameterized families. |
| {{anchor:N_LATTICE_POINTS:}} **''N_LATTICE_POINTS''** | \\ |
| * //Type:// [[common:Basic Types#Integer | Integer]] | {{anchor:torus:}} **''torus''** |
| * The number of [[/polytope/objects/Polytope/methods/Lattice points in polytopes/LATTICE_POINTS]] | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * The Császár Torus. Geometric realization by Frank Lutz,\\ Electronic Geometry Model No. 2001.02.069 |
| |
| {{anchor:BOUNDARY_LATTICE_POINTS:}} **''BOUNDARY_LATTICE_POINTS''** | \\ |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | {{anchor:simplex:}} **''simplex([[playground/playground#Int |Int]] d)''** |
| * The lattice points on the boundary of the polytope, including the vertices. | * //Parameters:// |
| | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * A __simplex__ of dimension //d//. |
| |
| {{anchor:LATTICE_POINTS_GENERATORS:}} **''LATTICE_POINTS_GENERATORS''** | \\ |
| * //Type:// [[common:Basic Types#Array | Array]] | {{anchor:complex_projective_plane:}} **''complex_projective_plane''** |
| * The lattice points generators in the polytope.\\ The output consists of three matrices [P,R,L], where\\ P are lattice points which are contained in the polytope\\ R are rays and L is the lineality.\\ Together they form a description of all lattice points.\\ Every lattice point can be described as\\ p + lambda*R + mu*L\\ where p is a row in P and lambda has only non-negative\\ integral coordinates and mu has arbitrary integral coordinates. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * The complex projective plane with the vertex-minimal triangulation by Kühnel and Brehm. |
| {{anchor:N_BOUNDARY_LATTICE_POINTS:}} **''N_BOUNDARY_LATTICE_POINTS''** | * //Example://\\ Construct the complex projective plane, store it in the variable $p2c, and print its homology group. \\ <code> > $p2c = complex_projective_plane(); |
| * //Type:// [[common:Basic Types#Integer | Integer]] | > print $p2c->HOMOLOGY; |
| * The number of [[/polytope/objects/Polytope/properties/Lattice points in polytopes/BOUNDARY_LATTICE_POINTS]] | ({} 0) |
| | ({} 0) |
| {{anchor:N_INTERIOR_LATTICE_POINTS:}} **''N_INTERIOR_LATTICE_POINTS''** | ({} 1) |
| * //Type:// [[common:Basic Types#Integer | Integer]] | ({} 0) |
| * The number of [[/polytope/objects/Polytope/properties/Lattice points in polytopes/INTERIOR_LATTICE_POINTS]] | ({} 1) |
| | |
| {{anchor:INTERIOR_LATTICE_POINTS:}} **''INTERIOR_LATTICE_POINTS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * The lattice points strictly in the interior of the polytope | |
| | |
| ---- | |
| ==== Matroid properties ==== | |
| Properties which belong to the corresponding (oriented) matroid | |
| {{anchor:CHIROTOPE:}} **''CHIROTOPE''** | |
| * //Type:// [[common:Basic Types#Text | Text]] | |
| * Chirotope corresponding to the [[/polytope/objects/Polytope/properties/Geometry/VERTICES]]. TOPCOM format. | |
| | |
| {{anchor:CIRCUITS:}} **''CIRCUITS''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * Circuits in [[/polytope/objects/Geometry/VectorConfiguration/properties/Input property/VECTORS]] | |
| | |
| {{anchor:COCIRCUITS:}} **''COCIRCUITS''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * Cocircuits in [[/polytope/objects/Geometry/VectorConfiguration/properties/Input property/VECTORS]] | |
| | |
| ---- | |
| ==== Optimization ==== | |
| These properties provide tools from linear, integer and dicrete optimization. In particular, linear programs are defined here. | |
| {{anchor:LP:}} **''LP''** | |
| * //Type:// [[polytope/LinearProgram | LinearProgram]] | |
| * Linear program applied to the polytope | |
| | |
| {{anchor:MILP:}} **''MILP''** | |
| * //Type:// [[polytope/MixedIntegerLinearProgram | MixedIntegerLinearProgram]] | |
| * Mixed integer linear program applied to the polytope | |
| | |
| ---- | |
| ==== Symmetry ==== | |
| These properties capture information of the object that is concerned with the action of permutation groups. | |
| {{anchor:GROUP:}} **''GROUP''** | |
| * //Type:// [[group/Group | Group]] | |
| * //Methods of GROUP:// | |
| * **''REPRESENTATIVE_INEQUALITIES''** | |
| * UNDOCUMENTED | |
| * //Properties of GROUP:// | |
| * **''MATRIX_ACTION''** | |
| * //Type:// [[group/MatrixActionOnVectors | MatrixActionOnVectors]] | |
| * //Properties of MATRIX_ACTION:// | |
| * **''VERTICES_ORBITS''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Alias for property [[/group/objects/MatrixActionOnVectors/properties/Symmetry/VECTORS_ORBITS]]. | |
| * **''POINTS_ACTION''** | |
| * //Type:// [[group/PermutationAction | PermutationAction]] | |
| * Alias for property [[/group/objects/Group/properties/Symmetry/INPUT_RAYS_ACTION]]. | |
| * **''COORDINATE_ACTION''** | |
| * //Type:// [[group/PermutationAction | PermutationAction]] | |
| * //Properties of COORDINATE_ACTION:// | |
| * **''POINTS_GENERATORS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * Alias for property [[/group/objects/Action/properties/Symmetry/INPUT_RAYS_GENERATORS]]. | |
| * **''N_POINTS_GENERATORS''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Alias for property [[/group/objects/Action/properties/Symmetry/N_INPUT_RAYS_GENERATORS]]. | |
| * **''REPRESENTATIVE_CERTIFIERS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * A matrix of representatives of all certifiers\\ for [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/POINTS_GENERATORS]] with respect to the\\ [[/polytope/objects/Polytope/properties/Symmetry/GROUP]].\\ A certifier is an integer point in the\\ given orbit polytope. \\ Note that the representative certifiers must be in \\ the same order as the corresponding nodes\\ in the [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/NOP_GRAPH]]. Further, the [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/CP_INDICES]]\\ refer to row indices of this property. | |
| * **''CP_INDICES''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * The row indices of all core points among\\ the [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/REPRESENTATIVE_CERTIFIERS]]. | |
| * **''N_REPRESENTATIVE_CERTIFIERS''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * The number of [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/REPRESENTATIVE_CERTIFIERS]]. | |
| * **''VERTICES_GENERATORS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * Alias for property [[/group/objects/Action/properties/Symmetry/RAYS_GENERATORS]]. | |
| * **''REPRESENTATIVE_CORE_POINTS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * A matrix of representatives of all core points in\\ the given orbit polytope.\\ A core point is an integer point whose orbit\\ polytope is lattice-free (i.e. does not contain\\ integer points besides its vertices). | |
| * **''NOP_GRAPH''** | |
| * //Type:// [[graph/Graph | Graph]] | |
| * The NOP-graph of [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/POINTS_GENERATORS]] with respect to the\\ [[/polytope/objects/Polytope/properties/Symmetry/GROUP]]. The nodes of the NOP-graph\\ correspond to the [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/REPRESENTATIVE_CERTIFIERS]], \\ which represent the different orbit polytopes\\ contained in the given orbit polytope. | |
| * **''N_VERTICES_GENERATORS''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Alias for property [[/group/objects/Action/properties/Symmetry/N_RAYS_GENERATORS]]. | |
| * **''N_REPRESENTATIVE_CORE_POINTS''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * The number of [[/polytope/objects/Polytope/properties/Symmetry/GROUP/properties/Symmetry/COORDINATE_ACTION/properties/REPRESENTATIVE_CORE_POINTS]]. | |
| * **''REPRESENTATIVE_VERTICES''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * Alias for property [[/polytope/objects/Cone/properties/Symmetry/GROUP/properties/Symmetry/REPRESENTATIVE_RAYS]]. | |
| * **''SYMMETRIC_RAYS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * | |
| * **''VERTICES_ACTION''** | |
| * //Type:// [[group/PermutationAction | PermutationAction]] | |
| * //Properties of VERTICES_ACTION:// | |
| * **''SYMMETRIZED_COCIRCUIT_EQUATIONS''** | |
| * //Type:// [[polytope/SymmetrizedCocircuitEquations | SymmetrizedCocircuitEquations]] | |
| * The cocircuit equations, projected to a certain direct sum of isotypic components | |
| * **''SYMMETRIC_FACETS''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * | |
| | |
| ---- | |
| ==== Triangulation and volume ==== | |
| Everything in this group is defined for [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]] polytopes only. | |
| {{anchor:SQUARED_RELATIVE_VOLUMES:}} **''SQUARED_RELATIVE_VOLUMES''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Array of the squared relative //k//-dimensional volumes of the simplices in\\ a triangulation of a //d//-dimensional polytope. | |
| | |
| {{anchor:MAHLER_VOLUME:}} **''MAHLER_VOLUME''** | |
| * //Type:// | |
| * Mahler volume (or volume product) of the polytope.\\ Defined as the volume of the polytope and the volume of its polar (for [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]], [[/polytope/objects/Polytope/properties/Geometry/CENTERED]] and [[/polytope/objects/Cone/properties/Geometry/FULL_DIM]] polytopes only).\\ Often studied for centrally symmetric convex bodies, where the regular cubes are conjectured to be the global minimiers. | |
| * //Example://\\ The following prints the Mahler volume of the centered 2-cube: \\ <code> > print cube(2)->MAHLER_VOLUME; | |
| 8 | |
| </code> | </code> |
| |
| {{anchor:VOLUME:}} **''VOLUME''** | \\ |
| * //Type:// | {{anchor:ball:}} **''ball([[playground/playground#Int |Int]] d)''** |
| * Volume of the polytope. | * //Parameters:// |
| * //Example://\\ The following prints the volume of the centered 3-dimensional cube with side length 2: \\ <code> > print cube(3)->VOLUME; | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| 8 | * //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> | </code> |
| |
| {{anchor:RELATIVE_VOLUME:}} **''RELATIVE_VOLUME''** | \\ |
| * //Type:// [[common:Set Types#Map | Map]] | {{anchor:cube_complex:}} **''cube_complex([[playground/playground#Array |Array]]<[[playground/playground#Int |Int]]> x)''** |
| * The //k//-dimensional Euclidean volume of a //k//-dimensional rational polytope \\ embedded in R^n.\\ This value is obtained by summing the square roots of the entries in SQUARED_RELATIVE_VOLUMES\\ using the function //naive_sum_of_square_roots//. Since this latter function\\ does not try very hard to compute the real value, you may have to resort to\\ a computer algebra package.\\ The value is encoded as a map collecting the coefficients of various roots encountered in the sum.\\ For example, {(3 1/2),(5 7)} represents sqrt{3}/2 + 7 sqrt{5}.\\ If the output is not satisfactory, please use a symbolic algebra package. | * //Parameters:// |
| * //Example://\\ The following prints the 2-dimensional volume of a centered square with side length 2 embedded in the 3-space (the result is 4): \\ <code> > $M = new Matrix([1,-1,1,0],[1,-1,-1,0],[1,1,-1,0],[1,1,1,0]); | * ''[[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. |
| $p = new Polytope<Rational>(VERTICES=>$M); | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]<[[playground/playground#Rational |Rational]]>'' |
| print $p->RELATIVE_VOLUME; | * 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. |
| {(1 4)} | * //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> | </code> |
| |
| {{anchor:TRIANGULATION:}} **''TRIANGULATION''** | \\ |
| * //Type:// [[topaz/GeometricSimplicialComplex | GeometricSimplicialComplex]] | {{anchor:surface:}} **''surface([[playground/playground#Int |Int]] g)''** |
| * //Properties of TRIANGULATION:// | |
| * **''GKZ_VECTOR''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * GKZ-vector\\ See Chapter 7 in Gelfand, Kapranov, and Zelevinsky:\\ Discriminants, Resultants and Multidimensional Determinants, Birkhäuser 1994 | |
| | |
| {{anchor:POLYTOPAL_SUBDIVISION:}} **''POLYTOPAL_SUBDIVISION''** | |
| * //Type:// [[fan/SubdivisionOfPoints | SubdivisionOfPoints]] | |
| * //Properties of POLYTOPAL_SUBDIVISION:// | |
| * **''REFINED_SPLITS''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * The splits that are coarsenings of the subdivision.\\ If the subdivision is regular these form the unique split decomposition of\\ the corresponding weight function. | |
| | |
| ---- | |
| ==== Unbounded polyhedra ==== | |
| These properties collect geometric information of a polytope only relevant if it is unbounded, e. g. the far face or the complex of bounded faces. | |
| {{anchor:UNBOUNDED_FACETS:}} **''UNBOUNDED_FACETS''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * Indices of facets that are unbounded. | |
| | |
| {{anchor:BOUNDED_COMPLEX:}} **''BOUNDED_COMPLEX''** | |
| * //Type:// [[fan/PolyhedralComplex | PolyhedralComplex]] | |
| * //Properties of BOUNDED_COMPLEX:// | |
| * **''GRAPH''** | |
| * //Type:// [[graph/Graph | Graph]] | |
| * //Properties of GRAPH:// | |
| * **''TOTAL_LENGTH''** | |
| * //Type:// | |
| * Sum of all [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH/properties/EDGE_LENGTHS]]. | |
| * **''EDGE_COLORS''** | |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | |
| * Each edge indicates the maximal dimension of a bounded\\ face containing it. Mainly used for visualization purposes. | |
| * **''EDGE_DIRECTIONS''** | |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | |
| * Difference of the vertices for each edge (only defined up to signs). | |
| * **''EDGE_LENGTHS''** | |
| * //Type:// [[common:Graph Types#EdgeMap | EdgeMap]] | |
| * The length of each edge measured in the maximum metric. | |
| * **''VERTEX_MAP''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * For every row of [[/fan/objects/Geometry/PolyhedralComplex/properties/Geometry/VERTICES]] this indicates the corresponding row in the\\ [[/fan/objects/Geometry/PolyhedralComplex/properties/Geometry/VERTICES]] of the parent polytope. | |
| | |
| {{anchor:N_BOUNDED_VERTICES:}} **''N_BOUNDED_VERTICES''** | |
| * //Type:// [[common:Basic Types#Int | Int]] | |
| * Number of bounded vertices (non-rays). | |
| | |
| {{anchor:SIMPLE_POLYHEDRON:}} **''SIMPLE_POLYHEDRON''** | |
| * //Type:// [[common:Basic Types#Bool | Bool]] | |
| * True if each bounded vertex of a (possibly unbounded) d-polyhedron has vertex degree d in the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH]].\\ The vertex degrees of the vertices on the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/FAR_FACE]] do not matter. | |
| | |
| {{anchor:TOWARDS_FAR_FACE:}} **''TOWARDS_FAR_FACE''** | |
| * //Type:// [[common:Algebraic Types#Vector | Vector]] | |
| * A linear objective function for which each unbounded edge is increasing;\\ only defined for unbounded polyhedra. | |
| | |
| {{anchor:FAR_FACE:}} **''FAR_FACE''** | |
| * //Type:// [[common:Set Types#Set | Set]] | |
| * Indices of vertices that are rays. | |
| | |
| ---- | |
| ==== Visualization ==== | |
| These properties are for visualization. | |
| {{anchor:VIF_CYCLIC_NORMAL:}} **''VIF_CYCLIC_NORMAL''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Reordered [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]] for 2d and 3d-polytopes.\\ Vertices are listed in the order of their appearance\\ when traversing the facet border counterclockwise seen from outside of the polytope.\\\\ For a 2d-polytope (which is a closed polygon), lists all vertices in the border traversing order.\\ Alias for property [[/polytope/objects/Cone/properties/Visualization/RIF_CYCLIC_NORMAL]]. | |
| | |
| {{anchor:VERTEX_LABELS:}} **''VERTEX_LABELS''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Unique names assigned to the [[/polytope/objects/Polytope/properties/Geometry/VERTICES]].\\ If specified, they are shown by visualization tools instead of vertex indices.\\\\ For a polytope build from scratch, you should create this property by yourself,\\ either manually in a text editor, or with a client program.\\\\ If you build a polytope with a construction function\\ taking some other input polytope(s), the labels are created the labels automatically\\ except if you call the function with a //no_labels// option. The exact format of the\\ abels is dependent on the construction, and is described in the corresponding help topic.\\ Alias for property [[/polytope/objects/Cone/properties/Visualization/RAY_LABELS]]. | |
| | |
| {{anchor:FACET_LABELS:}} **''FACET_LABELS''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Unique names assigned to the [[/polytope/objects/Cone/properties/Geometry/FACETS]], analogous to [[/polytope/objects/Polytope/properties/Visualization/VERTEX_LABELS]]. | |
| | |
| {{anchor:FTV_CYCLIC_NORMAL:}} **''FTV_CYCLIC_NORMAL''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Reordered transposed [[/polytope/objects/Polytope/properties/Combinatorics/VERTICES_IN_FACETS]]. Dual to [[/polytope/objects/Polytope/properties/Visualization/VIF_CYCLIC_NORMAL]].\\ Alias for property [[/polytope/objects/Cone/properties/Visualization/FTR_CYCLIC_NORMAL]]. | |
| | |
| {{anchor:INEQUALITY_LABELS:}} **''INEQUALITY_LABELS''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Unique names assigned to the [[/polytope/objects/Polytope/properties/Input property/INEQUALITIES]], analogous to [[/polytope/objects/Polytope/properties/Visualization/VERTEX_LABELS]]. | |
| | |
| {{anchor:POINT_LABELS:}} **''POINT_LABELS''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Unique names assigned to the [[/polytope/objects/Polytope/properties/Input property/POINTS]], analogous to [[/polytope/objects/Polytope/properties/Visualization/VERTEX_LABELS]].\\ Alias for property [[/polytope/objects/Cone/properties/Visualization/INPUT_RAY_LABELS]]. | |
| | |
| {{anchor:NEIGHBOR_VERTICES_CYCLIC_NORMAL:}} **''NEIGHBOR_VERTICES_CYCLIC_NORMAL''** | |
| * //Type:// [[common:Basic Types#Array | Array]] | |
| * Reordered [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH]]. Dual to [[/polytope/objects/Cone/properties/Visualization/NEIGHBOR_FACETS_CYCLIC_NORMAL]].\\ Alias for property [[/polytope/objects/Cone/properties/Visualization/NEIGHBOR_RAYS_CYCLIC_NORMAL]]. | |
| | |
| {{anchor:GALE_VERTICES:}} **''GALE_VERTICES''** | |
| * //Type:// [[common:Algebraic Types#Matrix | Matrix]] | |
| * Coordinates of points for an affine Gale diagram. | |
| | |
| {{anchor:SCHLEGEL_DIAGRAM:}} **''SCHLEGEL_DIAGRAM''** | |
| * //Type:// [[polytope/SchlegelDiagram | SchlegelDiagram]] | |
| * Holds one special projection (the Schlegel diagram) of the polytope. | |
| ===== Methods ===== | |
| | |
| ---- | |
| ==== Backward compatibility ==== | |
| These methods are provided for backward compatibility with older versions of polymake only. They should not be used in new code. | |
| {{anchor:N_EDGES:}} **''N_EDGES''** | |
| * //Returns:// [[common:Basic Types#Int | Int]] | |
| * The number of edges of the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH]] | |
| | |
| ---- | |
| ==== Combinatorics ==== | |
| These methods capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice. | |
| {{anchor:CD_INDEX:}} **''CD_INDEX''** | |
| * //Returns:// [[common:Basic Types#String | String]] | |
| * Prettily print the cd-index given in [[/polytope/objects/Polytope/properties/Combinatorics/CD_INDEX_COEFFICIENTS]] | |
| | |
| {{anchor:N_RIDGES:}} **''N_RIDGES''** | |
| * //Returns:// [[common:Basic Types#Int | Int]] | |
| * The number of ridges (faces of codimension 2) of the polytope\\ equals the number of edges of the [[/polytope/objects/Polytope/properties/Combinatorics/DUAL_GRAPH]] | |
| | |
| ---- | |
| ==== Geometry ==== | |
| These methods capture geometric information of the object. Geometric properties depend on geometric information of the object, like, e.g., vertices or facets. | |
| {{anchor:DIM:}} **''DIM''** | |
| * //Returns:// [[common:Basic Types#Int | Int]] | |
| * returns the dimension of the polytope | |
| | |
| {{anchor:INNER_DESCRIPTION:}} **''INNER_DESCRIPTION''** | |
| * //Returns:// [[common:Basic Types#Array | Array]] < [[common:Algebraic Types#Matrix | Matrix]] < [[polytope/tparams | tparams]] | |
| * Returns the inner description of a Polytope:\\ [V,L] where V are the vertices and L is the lineality space | |
| | |
| {{anchor:MINKOWSKI_CONE_POINT:}} **''MINKOWSKI_CONE_POINT([[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > point)''** | |
| * //Parameters:// | * //Parameters:// |
| * [[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > ''point'' : point in the Minkowski summand cone | * ''[[playground/playground#Int |Int]]'' ''g'' : genus |
| * //Returns:// [[polytope/Polytope | Polytope]] < [[common:Basic Types#Rational | Rational]] > | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * returns the Minkowski summand of a polytope P given by \\ a point in the [[/polytope/objects/Polytope/properties/Geometry/MINKOWSKI_CONE]]. | * Produce a __surface of genus //g//__. For //g// >= 0\\ the client produces an orientable surface, otherwise\\ it produces a non-orientable one. |
| |
| {{anchor:AMBIENT_DIM:}} **''AMBIENT_DIM''** | \\ |
| * //Returns:// [[common:Basic Types#Int | Int]] | {{anchor:rand_knot:}} **''rand_knot([[playground/playground#Int |Int]] n_edges)''** |
| * returns the dimension of the ambient space of the polytope | |
| | |
| {{anchor:labeled_vertices:}} **''labeled_vertices([[common:Basic Types#String | String]] label ...)''** | |
| * //Parameters:// | * //Parameters:// |
| * [[common:Basic Types#String | String]] ''label ...'' : vertex labels | * ''[[playground/playground#Int |Int]]'' ''n_edges'' : |
| * //Returns:// [[common:Set Types#Set | Set]] < [[common:Basic Types#Int | Int]] > | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| * Find the vertices by given labels. | * 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. |
| |
| {{anchor:OUTER_DESCRIPTION:}} **''OUTER_DESCRIPTION''** | \\ |
| * //Returns:// [[common:Basic Types#Array | Array]] < [[common:Algebraic Types#Matrix | Matrix]] < [[polytope/tparams | tparams]] | {{anchor:klein_bottle:}} **''klein_bottle''** |
| * Returns the outer description of a Polytope:\\ [F,A] where F are the facets and A is the affine hull | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| | * The Klein bottle. |
| |
| {{anchor:MINKOWSKI_CONE_COEFF:}} **''MINKOWSKI_CONE_COEFF([[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > coeff)''** | \\ |
| | {{anchor:multi_associahedron_sphere:}} **''multi_associahedron_sphere([[playground/playground#Int |Int]] n, [[playground/playground#Int |Int]] k)''** |
| * //Parameters:// | * //Parameters:// |
| * [[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > ''coeff'' : coefficient vector to the rays of the Minkowski summand cone | * ''[[playground/playground#Int |Int]]'' ''n'' : the number of vertices of the polygon |
| * //Returns:// [[polytope/Polytope | Polytope]] < [[common:Basic Types#Rational | Rational]] > | * ''[[playground/playground#Int |Int]]'' ''k'' : the number of diagonals that are allowed to mutually cross |
| * returns the Minkowski summand of a polytope P given by \\ a coefficient vector to the rays of the [[/polytope/objects/Polytope/properties/Geometry/MINKOWSKI_CONE]]. | * //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> |
| |
| ---- | \\ |
| ==== Lattice points in cones ==== | {{anchor:real_projective_plane:}} **''real_projective_plane''** |
| These methods capture information that depends on the lattice structure of the cone. polymake always works with the integer lattice. | * //Returns:// ''[[playground/playground/SimplicialComplex# |SimplicialComplex]]'' |
| {{anchor:FACET_POINT_LATTICE_DISTANCES:}} **''FACET_POINT_LATTICE_DISTANCES([[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > v)''** | * The real projective plane with its unique minimal triangulation on six vertices. |
| * //Parameters:// | |
| * [[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > ''v'' : point in the ambient space of the polytope | |
| * //Returns:// [[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Integer | Integer]] > | |
| * Vector containing the distances of a given point //v// from all facets | |
| |
| {{anchor:EHRHART_POLYNOMIAL_COEFF:}} **''EHRHART_POLYNOMIAL_COEFF''** | \\ |
| * //Returns:// [[common:Algebraic Types#Vector | Vector]] < [[common:Basic Types#Rational | Rational]] > | {{anchor:unknot:}} **''unknot([[playground/playground#Int |Int]] m, [[playground/playground#Int |Int]] n)''** |
| * Vector containing the coefficients of the [[/polytope/objects/Polytope/properties/Lattice points in cones/EHRHART_POLYNOMIAL]], ordered\\ by increasing degree of the corresponding term. | |
| | |
| {{anchor:N_LATTICE_POINTS_IN_DILATION:}} **''N_LATTICE_POINTS_IN_DILATION([[common:Basic Types#Int | Int]] n)''** | |
| * //Parameters:// | * //Parameters:// |
| * [[common:Basic Types#Int | Int]] ''n'' : dilation factor | * ''[[playground/playground#Int |Int]]'' ''m'' : |
| * //Returns:// [[common:Basic Types#Int | Int]] | * ''[[playground/playground#Int |Int]]'' ''n'' : |
| * The number of [[/polytope/objects/Polytope/methods/Lattice points in polytopes/LATTICE_POINTS]] in the //n//-th dilation of the polytope | * //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]]''. |
| |
| {{anchor:POLYTOPE_IN_STD_BASIS:}} **''POLYTOPE_IN_STD_BASIS([[polytope/Polytope | Polytope]] < [[common:Basic Types#Rational | Rational]] > P)''** | \\ |
| | {{anchor:sphere:}} **''sphere([[playground/playground#Int |Int]] d)''** |
| * //Parameters:// | * //Parameters:// |
| * [[polytope/Polytope | Polytope]] < [[common:Basic Types#Rational | Rational]] > ''P'' : polytope | * ''[[playground/playground#Int |Int]]'' ''d'' : dimension |
| * //Returns:// [[polytope/Polytope | Polytope]] < [[common:Basic Types#Rational | Rational]] > | * //Returns:// ''[[playground/playground/GeometricSimplicialComplex# |GeometricSimplicialComplex]]'' |
| * returns a polytope in the integer lattice basis if a [[/polytope/objects/Polytope/properties/Lattice points in cones/LATTICE_BASIS]] is given | * The //d//-dimensional __sphere__, realized as the boundary of the (//d//+1)-simplex. |
| |
| ---- | ---- |
| ==== Lattice points in polytopes ==== | ==== Producing other objects ==== |
| These methods capture information that depends on the lattice structure of the polytope. polymake always works with the integer lattice. | Functions producing big objects which are not contained in application topaz. |
| {{anchor:LATTICE_POINTS:}} **''LATTICE_POINTS''** | \\ |
| * //Returns:// [[common:Algebraic Types#Matrix | Matrix]] < [[common:Basic Types#Integer | Integer]] > | {{anchor:secondary_polyhedron:}} **''secondary_polyhedron([[playground/playground/HyperbolicSurface# |HyperbolicSurface]] s, [[playground/playground#Int |Int]] depth)''** |
| * Returns the lattice points in bounded Polytopes. | * //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. |
| |
| ---- | ---- |
| ==== Triangulation and volume ==== | ==== Topology ==== |
| These methods collect information about triangulations of the object and properties usually computed from such, as the volume. | The following functions compute topological invariants. |
| {{anchor:TRIANGULATION_INT_SIGNS:}} **''TRIANGULATION_INT_SIGNS''** | \\ |
| * //Returns:// [[common:Basic Types#Array | Array]] < [[common:Basic Types#Int | Int]] > | {{anchor:test:}} **''test''** |
| * the orientation of the simplices of [[/polytope/objects/Cone/properties/Triangulation and volume/TRIANGULATION_INT]] in the given order of the [[/polytope/objects/Polytope/properties/Input property/POINTS]] | * //Returns:// ''[[playground/playground#Int |Int]]'' |
| | * Calculate the betti numbers of a general chain complex over a field. |
| |
| ---- | \\ |
| ==== Unbounded polyhedra ==== | {{anchor:homology_and_cycles:}} **''homology_and_cycles''** |
| These methods collect geometric information of a polytope only relevant if it is unbounded, e. g. the far face or the complex of bounded faces. | |
| {{anchor:BOUNDED_HASSE_DIAGRAM:}} **''BOUNDED_HASSE_DIAGRAM''** | |
| * [[/polytope/objects/Polytope/properties/Combinatorics/HASSE_DIAGRAM]] constrained to affine vertices\\ Nodes representing the maximal inclusion-independent faces are connected to the top-node\\ regardless of their dimension | |
| |
| {{anchor:BOUNDED_GRAPH:}} **''BOUNDED_GRAPH''** | \\ |
| * Graph of the bounded subcomplex. | {{anchor:betti_numbers:}} **''betti_numbers''** |
| |
| {{anchor:BOUNDED_FACETS:}} **''BOUNDED_FACETS''** | \\ |
| * //Returns:// [[common:Set Types#Set | Set]] < [[common:Basic Types#Int | Int]] > | {{anchor:homology:}} **''homology''** |
| * Indices of [[/polytope/objects/Cone/properties/Geometry/FACETS]] that are bounded. | |
| |
| {{anchor:BOUNDED_VERTICES:}} **''BOUNDED_VERTICES''** | \\ |
| * //Returns:// [[common:Set Types#Set | Set]] < [[common:Basic Types#Int | Int]] > | {{anchor:cap_product:}} **''cap_product([[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]] cocycles, [[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]] cycles)''** |
| * Indices of [[/polytope/objects/Polytope/properties/Geometry/VERTICES]] that are no rays. | * //Parameters:// |
| | * ''[[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]]'' ''cocycles'' : |
| {{anchor:BOUNDED_DUAL_GRAPH:}} **''BOUNDED_DUAL_GRAPH''** | * ''[[playground/playground#CycleGroup |CycleGroup]]<[[playground/playground#cap |cap]]'' ''cycles'' : |
| * Dual graph of the bounded subcomplex. | * //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 ===== |
| |
| ---- | ---- |
| ==== Visualization ==== | ==== Topology ==== |
| These methods are for visualization. | The following property_types are topological invariants. |
| {{anchor:VISUAL_BOUNDED_GRAPH:}} **''VISUAL_BOUNDED_GRAPH''** | \\ |
| * //Returns:// [[polytope/Visual::PolytopeGraph | Visual::PolytopeGraph]] | {{anchor:filtration:}} **''Filtration<MatrixType>''** |
| * Visualize the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH]] of a polyhedron. | * //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. |
| |
| {{anchor:VISUAL_ORBIT_COLORED_GRAPH:}} **''VISUAL_ORBIT_COLORED_GRAPH''** | \\ |
| * //Returns:// [[polytope/Visual::PolytopeGraph | Visual::PolytopeGraph]] | {{anchor:chaincomplex:}} **''ChainComplex<MatrixType>''** |
| * Visualizes the graph of a symmetric cone:\\ All nodes belonging to one orbit get the same color. | * //Template Parameters:// |
| | * ''MatrixType'' : The type of the differential matrices. default: SparseMatrix<Integer> |
| {{anchor:VISUAL_DUAL_FACE_LATTICE:}} **''VISUAL_DUAL_FACE_LATTICE''** | * 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. |
| * //Returns:// [[polytope/Visual::PolytopeLattice | Visual::PolytopeLattice]] | * //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]]])); |
| * Visualize the dual [[/polytope/objects/Polytope/properties/Combinatorics/HASSE_DIAGRAM|face lattice]] of a polyhedron as a multi-layer graph. | </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 |
| {{anchor:SCHLEGEL:}} **''SCHLEGEL''** | </code>\\ The functions ''homology'', ''homology_and_cycles'' and ''betti_numbers'' can be used to analyse your complex. \\ <code> > print homology($cc,0); |
| * //Returns:// [[polytope/Visual::SchlegelDiagram | Visual::SchlegelDiagram]] | ({(2 1)} 1) |
| * Create a Schlegel diagram and draw it. | ({} 0) |
| | |
| {{anchor:VISUAL_DUAL:}} **''VISUAL_DUAL''** | |
| * //Returns:// [[common/Visual::Object | Visual::Object]] | |
| * Visualize the dual polytope as a solid 3-d object. The polytope must be [[/polytope/objects/Polytope/properties/Geometry/BOUNDED]] and [[/polytope/objects/Polytope/properties/Geometry/CENTERED]]. | |
| | |
| {{anchor:VISUAL_DUAL_GRAPH:}} **''VISUAL_DUAL_GRAPH''** | |
| * //Returns:// [[graph/Visual::Graph | Visual::Graph]] | |
| * Visualize the [[/polytope/objects/Polytope/properties/Combinatorics/DUAL_GRAPH]] of a polyhedron. | |
| | |
| {{anchor:VISUAL_FACE_LATTICE:}} **''VISUAL_FACE_LATTICE''** | |
| * //Returns:// [[polytope/Visual::PolytopeLattice | Visual::PolytopeLattice]] | |
| * Visualize the [[/polytope/objects/Polytope/properties/Combinatorics/HASSE_DIAGRAM]] of a polyhedron as a multi-layer graph. | |
| | |
| {{anchor:write_stl:}} **''write_stl([[common:Basic Types#String | String]] filename)''** | |
| * //Parameters:// | |
| * [[common:Basic Types#String | String]] ''filename'' : | |
| * Take a 3-polytope and write ASCII STL output. | |
| * //Example://\\ \\ <code> > dodecahedron()->write_stl("/tmp/dodecahedron.stl"); | |
| </code> | </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. |
| |
| {{anchor:VISUAL_GRAPH:}} **''VISUAL_GRAPH''** | \\ |
| * //Returns:// [[polytope/Visual::PolytopeGraph | Visual::PolytopeGraph]] | {{anchor:cell:}} **''Cell''** |
| * Visualize the [[/polytope/objects/Polytope/properties/Unbounded polyhedra/BOUNDED_COMPLEX/properties/Combinatorics/GRAPH]] of a polyhedron. | * |
| |
| {{anchor:GALE:}} **''GALE''** | \\ |
| * //Returns:// [[polytope/Visual::Gale | Visual::Gale]] | {{anchor:cyclegroup:}} **''CycleGroup<Scalar>''** |
| * Generate the Gale diagram of a //d//-polyhedron with at most //d+4// vertices. | * //Template Parameters:// |
| | * ''Scalar'' : integer type of matrix elements |
| | * 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. |
| |
| {{anchor:VISUAL:}} **''VISUAL''** | \\ |
| * //Returns:// [[polytope/Visual::Polytope | Visual::Polytope]] | {{anchor:intersectionform:}} **''IntersectionForm''** |
| * Visualize a polytope as a graph (if 1d), or as a solid object (if 2d or 3d),\\ or as a Schlegel diagram (4d). | * Parity and signature of the intersection form of a closed oriented 4k-manifold.\\ See ''[[playground/playground/SimplicialComplex#INTERSECTION_FORM |INTERSECTION_FORM]]''. |
| |
| | \\ |
| | {{anchor:homologygroup:}} **''HomologyGroup''** |
| | * 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. |
| |