This is an old revision of the document!
application topaz
The TOPology Application Zoo deals with abstract simplicial complexes.
A complex is given as a list of facets. You can ask for its global properties (manifold recognition
,
homology groups
, etc.), explore the local vertex environment (stars
, links
, etc.), and make a lot
of constructions.
The visualization means are constrained, as they are mostly based on the GRAPH
(1-skeleton) of a complex.
imports from:
uses:
Objects
- GeometricSimplicialComplex:
A geometric simplicial complex, i.e., a simplicial complex with a geometric realization. Scalar is the numeric data type used for the coordinates. - HyperbolicSurface:
A hyperbolic surface (noncompact, finite area) is given by a triangulation DCEL_DATA (the topological data) and PENNER_COORDINATES (the metric data). - 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 (greedy). The alternative is to use a canceling algorithm due to Forman (cancel) or both (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 - SimplicialComplex:
An abstract simplicial complex represented by its facets. - Visual::SimplicialComplex:
Visualization of the simplicial complex. - Visual::SimplicialComplexLattice:
Visualization of the HASSE_DIAGRAM of a simplicial complex as a multi-layer graph.
Functions
Combinatorics
These functions capture combinatorial information of the object. Combinatorial properties only depend on combinatorial data of the object like, e.g., the face lattice.
n_poset_homomorphisms(Graph<Directed> P, Graph<Directed> Q)
- Parameters:
- Returns:
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.
Comparing
These functions compare two SimplicialComplex
isomorphic(SimplicialComplex complex1, SimplicialComplex complex2)
- Parameters:
SimplicialComplex
complex1
:SimplicialComplex
complex2
:
- Returns:
Bool
- Determine whether two given complexes are combinatorially isomorphic.
The problem is reduced to graph isomorphism of the vertex-facet incidence graphs.
find_facet_vertex_permutations(SimplicialComplex complex1, SimplicialComplex complex2)
- Parameters:
SimplicialComplex
complex1
:SimplicialComplex
complex2
:
- 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.
pl_homeomorphic(SimplicialComplex complex1, SimplicialComplex complex2)
- Parameters:
SimplicialComplex
complex1
:SimplicialComplex
complex2
:
- Returns:
Bool
- Tries to determine whether two complexes are pl-homeomorphic by using
bistellar flips and a simulated annealing strategy.
You may specify the maximal number of rounds, how often the system
may relax before heating up and how much heat should be applied.
The function stops computing, once the size of the triangulation has not decreased
for rounds iterations. If the abs flag is set, the function stops
after rounds iterations regardless of when the last improvement took place.
Additionally, you may set the threshold min_n_facets for the number of facets when
the simplification ought to stop. Default is d+2 in theCLOSED_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.
Other
Special purpose functions.
poset_by_inclusion(Array<poset P)
- Parameters:
- 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
is_vertex_decomposition(SimplicialComplex complex, Array<Int> vertices)
- Parameters:
SimplicialComplex
complex
:
- Returns:
Bool
- Check whether a given ordered subset of the vertex set is a vertex decomposition.
Works for 1-, 2- and 3-manifolds only!
stiefel_whitney(Array<Set<Int» facets)
- Parameters:
- 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
star_of_zero(GeometricSimplicialComplex C)
- Parameters:
- 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
mixed_graph(SimplicialComplex complex)
- Parameters:
SimplicialComplex
complex
:
- Produces the mixed graph of a complex.
star_shaped_balls(GeometricSimplicialComplex P)
- Parameters:
- 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
stabbing_order(GeometricSimplicialComplex P)
- Parameters:
- Determine the stabbing partial order of a simplicial ball with respect to the origin.
The origin may be a vertex or not.
For details see Assarf, Joswig & Pfeifle:
Webs of stars or how to triangulate sums of polytopes, to appear
stanley_reisner(SimplicialComplex complex)
- Parameters:
SimplicialComplex
complex
:
- Returns:
Ideal
- Creates the Stanley-Reisner ideal of a simplicial complex.
is_generalized_shelling(Array<Set> FaceList)
- Parameters:
- Returns:
Bool
- Check if a given sequence of faces of a simplicial complex is a generalized shelling.
persistent_homology
random_discrete_morse(SimplicialComplex complex)
- Parameters:
SimplicialComplex
complex
:
- 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)
vietoris_rips_filtration<Coeff>(Matrix D, Array<Int> deg, Float step_size, Int k)
- Template Parameters:
Coeff
: desired coefficient type of the filtration
- Parameters:
- Returns:
Filtration<SparseMatrix<vietoris
- Constructs the k-skeleton of the Vietrois Rips filtration of a point set. The set is passed as its so-called “distance matrix”, whose (i,j)-entry is the distance between point i and j. This matrix can e.g. be computed using the distance_matrix function. The other inputs are an integer array containing the degree of each point, the desired distance step size between frames, and the dimension up to which to compute the skeleton. Redundant points will appear as seperate vertices of the complex. Setting k to |S| will compute the entire VR-Complex for each frame.
Producing a new simplicial complex from others
These functions construct a new SimplicialComplex from other objects of the same type.
star_deletion(SimplicialComplex complex, Set<Int> face)
- Parameters:
SimplicialComplex
complex
:Set<Int>
face
: specified by vertex indices.
Please uselabeled_vertices
if you want to specify the face by vertex labels.
- Returns:
SimplicialComplex
- Remove the star of a given face.
bistellar_simplification(SimplicialComplex complex)
- Parameters:
SimplicialComplex
complex
:
- Returns:
SimplicialComplex
- Heuristic for simplifying the triangulation of the given manifold
without changing its PL-type. The function uses
bistellar flips and a simulated annealing strategy.
You may specify the maximal number of rounds, how often the system
may relax before heating up and how much heat should be applied.
The function stops computing, once the size of the triangulation has not decreased
for rounds iterations. If the abs flag is set, the function stops
after rounds iterations regardless of when the last improvement took place.
Additionally, you may set the threshold min_n_facets for the number of facets when
the simplification ought to stop. Default is d+2 in theCLOSED_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.
simplicial_product
connected_sum(SimplicialComplex complex1, SimplicialComplex complex2, Int f1, Int f2)
- Parameters:
SimplicialComplex
complex1
:SimplicialComplex
complex2
:Int
f1
: default: 0Int
f2
: default: 0
- Returns:
SimplicialComplex
- Compute the connected sum of two complexes.
Parameters f_1 and f_2 specify which facet of the first and second complex correspondingly are glued together.
Default is the 0-th facet of both.
The vertices in the selected facets are identified with each other according to their order in the facet
(that is, in icreasing index order). The glueing facet iteself is not included in the connected sum.
The option permutation allows to get an alternative identification. It should specify a
permutation of the vertices of the second facet.
The vertices of the new complex get the original labels with_1
or_2
appended, according to the input complex
they came from. If you set the no_labels flag, the label generation will be omitted. * Example:
Glueing together two tori to make a genus 2 double torus, rotating the second one clockwise:
<code> > $cs = connected_sum(torus(),torus(),permutation⇒[1,2,0]); > print $cs→SURFACE.','.$cs→GENUS; 1,2 </code>
triang_neighborhood(SimplicialComplex complex, Rational width)
*SimplicialComplex
complex
: *Rational
width
: default: 0 * Create a triangulated tubular neighborhood of apure
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 computeCOORDINATES
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.
hom_poset
covering_relations(Graph<Directed> P)
*Graph<Directed>
P
: * Returns:Graph<Directed>
* Construct the covering relations of a poset
h_induced_quotient(SimplicialComplex C, Set<Int> vertices)
*SimplicialComplex
C
: *Set<Int>
vertices
: * Returns: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.
sum_triangulation(GeometricSimplicialComplex P, GeometricSimplicialComplex Q, IncidenceMatrix WebOfStars)
*GeometricSimplicialComplex
P
: first complex *GeometricSimplicialComplex
Q
: second complex *IncidenceMatrix
WebOfStars
: Every row corresponds to a full dimensional simplex in P and every column to a full dimensional simplex in Q. * Returns: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
induced_subcomplex(SimplicialComplex complex, Set<Int> vertices)
*SimplicialComplex
complex
: *Set<Int>
vertices
: * Returns:SimplicialComplex
* Produce the subcomplex consisting of all faces which are contained in the given set of vertices.
foldable_prism(GeometricSimplicialComplex complex)
*GeometricSimplicialComplex
complex
: * Returns:GeometricSimplicialComplex
* Produce a prism over a givenSimplicialComplex
.
edge_contraction(SimplicialComplex complex)
*SimplicialComplex
complex
: * Returns: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.
disjoint_union(SimplicialComplex complex1, SimplicialComplex complex2)
*SimplicialComplex
complex1
: *SimplicialComplex
complex2
: * Returns:SimplicialComplex
* Produce the disjoint union of the two given complexes.
stellar_subdivision
web_of_stars(Array<Int> poset_hom, Array<Set<Set<Int»> star_shaped_balls, Array<Set<Int» triang)
*Array<Int>
poset_hom
: the poset homomorphism from stabbing order to star-shaped balls *Array<Set<Set<Int»>
star_shaped_balls
: the collection of star-shaped balls of T *Array<Set<Int»
triang
: the facets of the underlying triangulation of Q * Returns:IncidenceMatrix
* Produce a web of stars from two given triangulations
and a map between them.
barycentric_subdivision(SimplicialComplex complex)
*SimplicialComplex
complex
: * Returns:SimplicialComplex
* Computes the barycentric subdivision of complex. * Example:
To subdivide a triangle into six new triangles, do this:
<code> > $b = barycentric_subdivision(simplex(2)); </code>
union(SimplicialComplex complex1, SimplicialComplex complex2)
*SimplicialComplex
complex1
: *SimplicialComplex
complex2
: * Returns:SimplicialComplex
* Produce the union of the two given complexes, identifying
vertices with equal labels.
cone(SimplicialComplex complex, Int k)
*SimplicialComplex
complex
: *Int
k
: default is 1 * Returns:SimplicialComplex
* 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']); > print $c→FACETS; {0 1 2 3 4} </code>
<code> > print $c→VERTEX_LABELS; 0 1 2 foo bar </code>
join_complexes(SimplicialComplex complex1, SimplicialComplex complex2)
*SimplicialComplex
complex1
: *SimplicialComplex
complex2
: * Returns:SimplicialComplex
* Creates the join of complex1 and complex2.
alexander_dual(SimplicialComplex complex)
*SimplicialComplex
complex
: * Returns: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.
deletion(SimplicialComplex complex, Set<Int> face)
*SimplicialComplex
complex
: *Set<Int>
face
: specified by vertex indices.
Please uselabeled_vertices
if you want to specify the face by vertex labels. * Returns:SimplicialComplex
* Remove the given face and all the faces containing it.
link_complex(SimplicialComplex complex, Set<Int> face)
*SimplicialComplex
complex
: *Set<Int>
face
: * Returns:SimplicialComplex
* Produce the link of a face of the complex
star(SimplicialComplex complex, Set<Int> face)
*SimplicialComplex
complex
: *Set<Int>
face
: * Returns:SimplicialComplex
* Produce the star of the face of the complex.
colored_ball_from_colored_sphere(SimplicialComplex complex)
*SimplicialComplex
complex
: * Returns: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 labelednew_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.
poset_homomorphisms(Graph<Directed> P, Graph<Directed> Q)
*Graph<Directed>
P
: *Graph<Directed>
Q
: * Returns:Array<Array<Int»
* Enumerate all order preserving maps from one poset to another
iterated_barycentric_subdivision(SimplicialComplex complex, Int k)
*SimplicialComplex
complex
: *Int
k
: * Returns:SimplicialComplex
* Computes the k-th barycentric subdivision of complex by iteratively callingbarycentric
.
k_skeleton
suspension(SimplicialComplex complex, Int k)
*SimplicialComplex
complex
: *Int
k
: default value is 1 * Returns:SimplicialComplex
* Produce the k-suspension over a given simplicial complex.
bs2quotient(Polytope P, SimplicialComplex complex)
*Polytope
P
: the underlying polytope *SimplicialComplex
complex
: a sufficiently fine subdivision of P, for example the second barycentric subdivision * Returns:SimplicialComplex
* Create a simplicial complex from a simplicial subdivision of a given complex
by identifying vertices on the boundary of the original complex according to a group that acts on vertices. —- ==== Producing a simplicial complex from other objects ==== These functions construct a new SimplicialComplex from other objects.
vietoris_rips_complex(Matrix D, Rational delta)
*Matrix
D
: the “distance matrix” of the point set (can be upper triangular) *Rational
delta
: * Returns: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.
independence_complex(Matroid matroid)
*Matroid
matroid
: * Returns:SimplicialComplex
* Produce the independence complex of a given matroid.
If no_labels is set to 1, the labels are not copied.
clique_complex(Graph graph)
*Graph
graph
: * Returns:SimplicialComplex
* Produce the clique complex of a given graph, that is, the simplicial
complex that has an n-dimensional facet for each n+1-clique.
If no_labels is set to 1, the labels are not copied. * Example:
Create the clique complex of a simple graph with one 3-clique and
one 2-clique, not creating labels.
<code> > $g = graph_from_edges(0,1],[0,2],[1,2],[2,3); > $c = clique_complex($g,no_labels⇒1); > print $c→FACETS; {0 1 2} {2 3} </code> —- ==== Producing from scratch ==== With these clients you can create special examples of simplicial complexes and complexes belonging to parameterized families.
torus
*SimplicialComplex
* The Császár Torus. Geometric realization by Frank Lutz,
Electronic Geometry Model No. 2001.02.069
simplex(Int d)
*Int
d
: dimension * Returns:SimplicialComplex
* A simplex of dimension d.
complex_projective_plane
*SimplicialComplex
* The complex projective plane with the vertex-minimal triangulation by Kühnel and Brehm. * Example:
Construct the complex projective plane, store it in the variable $p2c, and print its homology group.
<code> > $p2c = complex_projective_plane(); > print $p2c→HOMOLOGY; ({} 0) ({} 0) ({} 1) ({} 0) ({} 1) </code>
ball(Int d)
*Int
d
: dimension * Returns: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>
Parameters: *Array<Int>
x
: specifies the shape of the pile:
d=x.size is the dimension of the cubes to be stacked, and the stack will be
x_1 by x_2 by … by x_d cubes. * Returns:GeometricSimplicialComplex<Rational>
* Produces a triangulated pile of hypercubes, arranged in a d-dimensional array.
Each cube is split into d! tetrahedra, and the tetrahedra are all grouped around
one of the diagonal axes of the cube. * Example:
Arrange four triangulated 3-cubes to form a big 2 by 2 cube:
<code> > $cc = cube_complex([2,2,2]); > print $cc→description; 2x2x2 Pile of 3-dimensional triangulated cubes. </code>
surface(Int g)
*Int
g
: genus * Returns:SimplicialComplex
* Produce a surface of genus g. For g >= 0
the client produces an orientable surface, otherwise
it produces a non-orientable one.
rand_knot(Int n_edges)
*Int
n_edges
: * Returns:SimplicialComplex
* Produce a random knot (or link) as a polygonal closed curve in 3-space.
The knot (or each connected component of the link) has n_edges edges.
The vertices are uniformly distributed in [-1,1]3, unless the on_sphere option is set.
In the latter case the vertices are uniformly distributed on the 3-sphere. Alternatively
the brownian option produces a knot by connecting the ends of a simulated brownian motion.
klein_bottle
*SimplicialComplex
* The Klein bottle.
multi_associahedron_sphere(Int n, Int k)
*Int
n
: the number of vertices of the polygon *Int
k
: the number of diagonals that are allowed to mutually cross * Returns: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_{2n}.
Δ(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-2k-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>
real_projective_plane
*SimplicialComplex
* The real projective plane with its unique minimal triangulation on six vertices.
Parameters: *Int
m
: *Int
n
: * Returns: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 theCOORDINATES
.
sphere(Int d)
*Int
d
: dimension * Returns:GeometricSimplicialComplex
* The d-dimensional sphere, realized as the boundary of the (d+1)-simplex. —- ==== Producing other objects ==== Functions producing big objects which are not contained in application topaz.
secondary_polyhedron(HyperbolicSurface s, Int depth)
*HyperbolicSurface
s
: *Int
depth
: * Returns:Polytope<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. —- ==== Topology ==== The following functions compute topological invariants.
test
*Int
* Calculate the betti numbers of a general chain complex over a field.
homology_and_cycles
betti_numbers
homology
cap_product(CycleGroup<cap cocycles, CycleGroup<cap cycles)
*CycleGroup<cap
cocycles
: *CycleGroup<cap
cycles
: * Returns:Pair<CycleGroup<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 ===== —- ==== Topology ==== The following property_types are topological invariants.
Filtration<MatrixType>
*MatrixType
: * A filtration of chain complexes. * Methods of Filtration: *dim
* Returns:Int
* Returns the dimension of the maximal cells in the last frame of the filtration. *n_cells
* Returns:Int
* Returns the number of cells in the last frame of the filtration. *cells
* Returns:Array<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(Int d, Int t)
* Parameters: *Int
d
: *Int
t
: * Returns the d-boundary matrix of the t-th frame of the filtration. *n_frames
* Returns:Int
* Returns the number of frames in of the filtration.
ChainComplex<MatrixType>
*MatrixType
: The type of the differential matrices. default: SparseMatrix<Integer> * A finite chain complex, represented as its boundary matrices.
Check out the tutorial on the polymake homepage for examples on constructing ChainComplexes and computing their homology. * Example:
You can create a new ChainComplex by passing the Array of differential matrices (as maps via _left_ multiplication):
<code> > $cc = new ChainComplex(new Array<SparseMatrix<Integer»([2,0])); </code>
Note that this creates a ChainComplex consisting three differential matrices – the trivial zeroth and last ones
are omitted in the constructor.
You can look at the boundary matrices:
<code> > print $cc→boundary_matrix(1); 2 0 </code>
The functionshomology
,homology_and_cycles
andbetti_numbers
can be used to analyse your complex.
<code> > print homology($cc,0); ({(2 1)} 1) ({} 0) </code> * Methods of ChainComplex: *boundary_matrix(Int d)
* Parameters: *Int
d
: * Returns:ChainComplex
* Returns the d-boundary matrix of the chain complex. *dim
* Returns:Int
* Returns the number of non-empty modules in the complex.
Cell
*
CycleGroup<Scalar>
*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.
IntersectionForm
* Parity and signature of the intersection form of a closed oriented 4k-manifold.
SeeINTERSECTION_FORM
.
HomologyGroup
* A group is encoded as a sequence ( { (t1 m1) … (tn mn) } f) of non-negative integers,
with t1 > t2 > … > tn > 1, plus an extra non-negative integer f.
The group is isomorphic to (Z/t1)m1 × … × (Z/tn)mn × Zf,
where Z0 is the trivial group.
Access methods:
- playground/playground.1553547384.txt.gz
- Last modified: 2019/03/25 20:56
- by oroehrig