Conley Theory Functions

mvf_information(lc::LefschetzComplex, mvf::CellSubsets)

Extract basic information about a multivector field.

The input argument lc contains the Lefschetz complex, and mvf describes the multivector field. The function returns the information in the form of a Dict{String,Any}. You can use the command keys to see the keyset of the return dictionary:

• "N mv": Number of multivectors
• "N critical": Number of critcal multivectors
• "N regular": Number of regular multivectors
• "Lengths critical": Length distribution of critical multivectors
• "Lengths regular": Length distribution of regular multivectors

In the last two cases, the dictionary entries are vectors of pairs (length,frequency), where each pair indicates that there are frequency multivectors of length length.

create_mvf_hull(lc::LefschetzComplex, mvfbase::Vector{Vector{Int}})

Create the smallest multivector field containing the given sets.

The resulting multivector field has the property that every set of the form mvfbase[k] is contained in a minimal multivector. Notice that these sets do not have to be disjoint, and that not even their locally closed hulls have to be disjoint. In the latter case, this leads to two such sets having to be contained in the same multivector. If the sets in mvfbase are poorly chosen, one might end up with extremely large multivectors due to the above potential merging of locally closed hulls.

create_mvf_hull(lc::LefschetzComplex, mvfbase::Vector{Vector{String}})

Create the smallest multivector field containing the given sets.

The resulting multivector field has the property that every set of the form mvfbase[k] is contained in a minimal multivector. Notice that these sets do not have to be disjoint, and that not even their locally closed hulls have to be disjoint. In the latter case, this leads to two such sets having to be contained in the same multivector. If the sets in mvfbase are poorly chosen, one might end up with extremely large multivectors due to the above potential merging of locally closed hulls.

create_planar_mvf(lc::LefschetzComplex, coords::Vector{<:Vector{<:Real}}, vf)

Create a planar multivector field from a regular vector field.

The function expects a planar Lefschetz complex lc and a coordinate vector coords of coordinates for all the 0-dimensional cells in the complex. Moreover, the underlying vector field is specified by the function vf(z::Vector{Float64})::Vector{Float64}, where both the input and output vectors have length two. The function create_planar_mvf returns a multivector field mvf on lc, which can then be further analyzed using for example the function connection_matrix.

The input data lc and coords can be generated using one of the following methods:

• create_cubical_rectangle
• create_simplicial_rectangle
• create_simplicial_delaunay

In each case, the provided coordinate vector can be transformed to the correct bounding box values using the conversion function convert_planar_coordinates.

Example 1

Suppose we define a sample vector field using the commands

function samplevf(x::Vector{Float64})
    #
    # Sample vector field with nontrivial Morse decomposition
    #
    x1, x2 = x
    y1 = x1 * (1.0 - x1*x1 - 3.0*x2*x2)
    y2 = x2 * (1.0 - 3.0*x1*x1 - x2*x2)
    return [y1, y2]
end

One first creates a triangulation of the enclosing box, which in this case is given by [-2,2] x [-2,2] using the commands

n = 21
lc, coords = create_simplicial_rectangle(n,n);
coordsN = convert_planar_coordinates(coords,[-2.0,-2.0],[2.0,2.0]);

The multivector field is then generated using

mvf = create_planar_mvf(lc,coordsN,samplevf);

and the commands

cm = connection_matrix(lc, mvf);
cm.conley
full_from_sparse(cm.matrix)

finally show that this vector field gives rise to a Morse decomposition with nine Morse sets, and twelve connecting orbits. Using the commands

fname = "morse_test.pdf"
plot_planar_simplicial_morse(lc, coordsN, fname, cm.morse, pv=true)

these Morse sets can be visualized. The image will be saved in fname.

Example 2

An example with periodic orbits can be generated using the vector field

function samplevf2(x::Vector{Float64})
    #
    # Sample vector field with nontrivial Morse decomposition
    #
    x1, x2 = x
    c0 = x1*x1 + x2*x2
    c1 = (c0 - 4.0) * (c0 - 1.0)
    y1 = -x2 + x1 * c1
    y2 =  x1 + x2 * c1
    return [-y1, -y2]
end

The Morse decomposition can now be computed via

n2 = 51
lc2, coords2 = create_cubical_rectangle(n2,n2);
coords2N = convert_planar_coordinates(coords2,[-4.0,-4.0],[4.0,4.0]);
mvf2 = create_planar_mvf(lc2,coords2N,samplevf2);
cm2 = connection_matrix(lc2, mvf2);
cm2.conley
cm2.poset
full_from_sparse(cm2.matrix)

fname2 = "morse_test2.pdf"
plot_planar_cubical_morse(lc2, fname2, cm2.morse, pv=true)

In this case, one obtains three Morse sets: One is a stable equilibrium, one is an unstable periodic orbit, and the last is a stable periodic orbit.

create_spatial_mvf(lc::LefschetzComplex, coords::Vector{<:Vector{<:Real}}, vf)

Create a spatial multivector field from a regular vector field.

The function expects a three-dimensional Lefschetz complex lc and a coordinate vector coords of coordinates for all the 0-dimensional cells in the complex. Moreover, the underlying vector field is specified by the function vf(z::Vector{Float64})::Vector{Float64}, where both the input and output vectors have length three. The function create_spatial_mvf returns a multivector field mvf on lc, which can then be further analyzed using for example the function connection_matrix.

The input data lc and coords has to be of one of the following two types:

• lc is a tetrahedral mesh of a region in three dimensions. In other words, the underlying Lefschetz complex is in fact a simplicial complex, and the vector coords contains the vertex coordinates.
• lc is a three-dimensional cubical complex, i.e., it is the closure of a collection of three-dimensional cubes in space. The vertex coordinates can be slightly perturbed from the original position in the cubical lattice, as long as the overall structure of the complex stays intact. In that case, the faces are interpreted as Bezier surfaces with straight edges.

Example 1

Suppose we define a sample vector field using the commands

function samplevf(x::Vector{Float64})
    #
    # Sample vector field with nontrivial Morse decomposition
    #
    x1, x2, x3 = x
    y1 = x1 * (1.0 - x1*x1)
    y2 = -x2
    y3 = -x3
    return [y1, y2, y3]
end

One first creates a cubical complex covering the interesting dynamics, say the trapping region [-1.5,1.5] x [-1,1] x [-1,1], using the commands

lc, coords = create_cubical_box(3,3,3);
coordsN = convert_spatial_coordinates(coords,[-1.5,-1.0,-1.0],[1.5,1.0,1.0]);

The multivector field is then generated using

mvf = create_spatial_mvf(lc,coordsN,samplevf);

and the commands

cm = connection_matrix(lc, mvf);
cm.conley
full_from_sparse(cm.matrix)

finally show that this vector field gives rise to a Morse decomposition with three Morse sets, and two connecting orbits.

extract_multivectors(lc::LefschetzComplex, mvf::Vector{Vector{Int}},
                     scells::Vector{Int})

Extract all multivectors containing a provided selection of cells.

The function returns all multivectors which contain at least one of the cells in the input vector scells. The return argument has type Vector{Vector{Int}}.

extract_multivectors(lc::LefschetzComplex, mvf::Vector{Vector{String}},
                     scells::Vector{String})

Extract all multivectors containing a provided selection of cells.

The function returns all multivectors which contain at least one of the cells in the input vector scells. The return argument has type Vector{Vector{String}}.

planar_nontransverse_edges(lc::LefschetzComplex, coords::Vector{<:Vector{<:Real}}, vf;
                           npts::Int=100)

Find all edges of a planar Lefschetz complex which are not flow transverse.

The Lefschetz complex is given in lc, the coordinates of all vertices of the complex in coords, and the vector field is specified in vf. The optional parameter npts determines how many points along an edge are evaluated for the transversality check. The function returns a list of nontransverse edges as Vector{Int}, which contains the edge indices.

isoinvset_information(lc::LefschetzComplex, mvf::CellSubsets, iis::Cells)

Compute basic information about an isolated invariant set.

The input argument lc contains the Lefschetz complex, and mvf describes the multivector field. The isolated invariant set is specified in the argument iis. The function returns the information in the form of a Dict{String,Any}. The command keys can be used to see the keyset of the return dictionary. These describe the following information:

• "Conley index" contains the Conley index of the isolated invariant set.
• "N multivectors" contains the number of multivectors in the isolated invariant set.

conley_index(lc::LefschetzComplex, subcomp::Vector{String})

Determine the Conley index of a Lefschetz complex subset.

The function raises an error if the subset subcomp is not locally closed. The computations are performed over the field associated with the Lefschetz complex boundary matrix.

conley_index(lc::LefschetzComplex, subcomp::Vector{Int})

Determine the Conley index of a Lefschetz complex subset.

The function raises an error if the subset subcomp is not locally closed. The computations are performed over the field associated with the Lefschetz complex boundary matrix.

morse_sets(lc::LefschetzComplex, mvf::CellSubsets; poset::Bool=false)

Find the nontrivial Morse sets of a multivector field on a Lefschetz complex.

The input argument lc contains the Lefschetz complex, and mvf describes the multivector field. The function returns the nontrivial Morse sets as a Vector{Vector{Int}}. If the optional argument poset=true is added, then the function returns both the Morse sets and the adjacency matrix of the Hasse diagram of the underlying poset.

morse_interval(lc::LefschetzComplex, mvf::CellSubsets,
               ms::CellSubsets)

Find the isolated invariant set for a Morse set interval.

The input argument lc contains the Lefschetz complex, and mvf describes the multivector field. The collection of Morse sets are contained inms. All of these sets should be Morse sets in the sense of being strongly connected components of the flow graph. (Nevertheless, this will be enforced in the function!) In other words, the sets in ms should be determined using the function morse_sets!

The function returns the smallest isolated invariant set which contains the Morse sets and their connections as a Vector{Int}.

restrict_dynamics(lc::LefschetzComplex, mvf::CellSubsets, lcsub::Cells)

Restrict a multivector field to a Lefschetz subcomplex.

For a given multivector field mvf on a Lefschetz complex lc, and a subcomplex which is given by the locally closed set represented by lcsub, create the associated Lefschetz subcomplex lcreduced and the induced multivector field mvfreduced on the subcomplex. The multivectors of the new multivector field are the intersections of the original multivectors and the subcomplex.

remove_exit_set(lc::LefschetzComplex, mvf::CellSubsets)

Exit set removal for a multivector field on a Lefschetz subcomplex.

It is assumed that the Lefschetz complex lc is a topological manifold and that mvf contains a multivector field that is created via either create_planar_mvf or create_spatial_mvf. The function identifies cells on the boundary at which the flows exits the region covered by the Lefschetz complex. If this exit set is closed, we have found an isolated invariant set and the function returns a Lefschetz complex lcr restricted to it, as well as the restricted multivector field mvfr. If the exit set is not closed, a warning is displayed and the function returns the restricted Lefschetz complex and multivector field obtained by removing the closure of the exit set. In the latter case, unexpected results might be obtained.

connection_matrix(lc::LefschetzComplex, mvf::CellSubsets;
                  [algorithm::String],
                  [returnbasis::Bool])

Compute a connection matrix for the multivector field mvf on the Lefschetz complex lc over the field associated with the Lefschetz complex boundary matrix.

The function returns an object of type ConleyMorseCM. If the optional argument returnbasis::Bool=true is given, then the function also returns a dictionary which gives the basis for the connection matrix columns in terms of the original labels. Finally, it is possible to invoke the connection matrix computation with one of four different algorithms, by passing the optional argument algorithm::String:

• algorithm = "DLMS" selects the algorithm due to Dey, Lipinski, Mrozek, Slechta (SIAM Journal on Applied Dynamical Systems, 2024),
• algorithm = "DHL" selects the algorithm due to Dey, Haas, Lipinski (SIAM Journal on Applied Dynamical Systems, 2026),
• algorithm = "HMS" selects the algorithm due to Harker, Mischaikow, Spendlove (Journal of Applied and Computational Topology, 2021),
• algorithm = "pmorse" selects a parallelized algorithm based on Morse reductions.

By default, the function uses the parallelized Morse reduction algorithm pmorse. If the flag returnbasis::Bool=true is given, then the function automatically chooses the slower matrix-based algorithm = "DLMS".

cm_reduce_dlms24!(matrix::SparseMatrix, psetvec::Vector{Int};
                  [returnbasis::Bool],[returntm::Bool])

Compute the connection matrix.

This function uses the algorithm from the paper Dey, Lipinski, Mrozek, and Slechta (SIAM Journal on Applied Dynamical Systems, 2024). It assumes that matrix is upper triangular and filtered according to psetvec. Modifies the argument matrix.

Return values:

• cmatrix: Connection matrix
• cmatrix_cols: Columns of the connection matrix in the boundary
• basisvecs (optional): If the argument returnbasis=true is given, this returns information about the computed basis. The k-th entry of basisvecs is a vector containing the columns making up the k-th basis vector, which corresponds to column cmatrix_cols[k].
• tmatrix (optional): If the argument returntm=true is given in addition to returnbasis=true, then instead of basisvecs the function returns the complete transformation matrix. In this case, basicvecs is not returned.

cm_reduce_dhl26!(matrix::SparseMatrix, psetvec::Vector{Int})

Compute the connection matrix.

This function uses the algorithm from the paper Dey, Haas, and Lipinski (SIAM Journal on Applied Dynamical Systems, 2026). Assumes that matrix is upper triangular and filtered according to psetvec. Modifies the argument matrix.

Return values:

• cmatrix: Connection matrix
• cmatrix_cols: Columns of the connection matrix in the boundary

cm_reduce_hms21(matrix::SparseMatrix, psetvec::Vector{Int})

Compute the connection matrix.

This function uses the algorithm from the paper Harker, Mischaikow, Spendlove (Journal of Applied and Computational Topology, 2021). Assumes that matrix is upper triangular and filtered according to psetvec.

Return values:

• cmatrix: Connection matrix
• cmatrix_cols: Columns of the connection matrix in the boundary

cm_reduce_pmorse26(matrix::SparseMatrix, psetvec::Vector{Int})

Compute the connection matrix.

This function uses a parallelized Morse matching algorithm. Assumes that matrix is upper triangular and filtered according to psetvec.

Return values:

• cmatrix: Connection matrix
• cmatrix_cols: Columns of the connection matrix in the boundary

forman_critical_cells(lc::LefschetzComplex, fvf::CellSubsets)

Find all critical cells of a Forman vector field.

This function returns all critical cells of the Forman vector field fvf on the Lefschetz complex lc.

Example

julia> labels = ["a","b","c","d"];

julia> simplices = [["a","b"], ["b","c"], ["c","d"]];

julia> lc = create_simplicial_complex(labels, simplices, p=5);

julia> fvf = [["ab","b"], ["bc","c"]];

julia> c = forman_critical_cells(lc, fvf);

julia> println(c)
["a", "d", "cd"]

forman_all_cell_types(lc::LefschetzComplex, fvf::CellSubsets)

Find all cell types of a Forman vector field.

This function returns all critical cells, all arrow sources, and all arrow targets of the Forman vector field fvf on the Lefschetz complex lc.

Example

julia> labels = ["a","b","c","d"];

julia> simplices = [["a","b"], ["b","c"], ["c","d"]];

julia> lc = create_simplicial_complex(labels, simplices, p=5);

julia> fvf = [["ab","b"], ["bc","c"]];

julia> c, s, t = forman_all_cell_types(lc, fvf);

julia> println(c)
["a", "d", "cd"]

julia> println(s)
["b", "c"]

julia> println(t)
["ab", "bc"]

forman_conley_maps(lc::LefschetzComplex, fvf::CellSubsets)

Compute the maps associated with the Conley complex of a Forman gradient field

This function returns the chain maps and chain homotopy associated with the Conley complex of a Forman gradient vector field. These maps are computed via the stabilized combinatorial flow. The function returns the following variables:

• pp:SparseMatrix: The chain equivalence which maps the Lefschetz complex to the Conley complex
• jj:SparseMatrix: The chain equivalence which maps the Conley complex to the Lefschetz complex
• hh:SparseMatrix: The chain homotopy between jj*pp and the identity
• cc:Cells: The list of critical cells which make up the Conley complex

Example

julia> labels = ["a","b","c","d"];

julia> simplices = [["a","b"], ["b","c"], ["c","d"]];

julia> lc = create_simplicial_complex(labels, simplices, p=5);

julia> fvf = [["ab","b"], ["bc","c"]];

julia> pp, jj, hh, cc = forman_conley_maps(lc, fvf);

julia> sparse_show(pp, cc, lc.labels)
  ┆  a  b  c  d ab bc cd
--┆---------------------
 a┆  1  1  1  .  .  .  .
 d┆  .  .  .  1  .  .  .
cd┆  .  .  .  .  .  .  1

julia> sparse_show(jj, lc.labels, cc)
  ┆  a  d cd
--┆---------
 a┆  1  .  .
 b┆  .  .  .
 c┆  .  .  .
 d┆  .  1  .
ab┆  .  .  1
bc┆  .  .  1
cd┆  .  .  1

julia> sparse_show(hh, lc.labels, lc.labels)
  ┆  a  b  c  d ab bc cd
--┆---------------------
 a┆  .  .  .  .  .  .  .
 b┆  .  .  .  .  .  .  .
 c┆  .  .  .  .  .  .  .
 d┆  .  .  .  .  .  .  .
ab┆  .  4  4  .  .  .  .
bc┆  .  .  4  .  .  .  .
cd┆  .  .  .  .  .  .  .

julia> sparse_show(jj*pp - lc.boundary*hh - hh*lc.boundary)
 1 . . . . . .
 . 1 . . . . .
 . . 1 . . . .
 . . . 1 . . .
 . . . . 1 . .
 . . . . . 1 .
 . . . . . . 1

forman_comb_flow(lc::LefschetzComplex, fvf::Vector{Vector{String}})

Compute Forman's combinatorial flow and the associated chain homotopy.

This function returns matrix representations of Forman's combinatorial flow phi, and of the associated chain homotopy gamma.

Example

julia> labels = ["a","b","c","d"];

julia> simplices = [["a","b"], ["b","c"], ["c","d"]];

julia> lc = create_simplicial_complex(labels, simplices, p=5);

julia> fvf = [["ab","b"], ["bc","c"]];

julia> phi, gamma = forman_comb_flow(lc, fvf);

julia> full_from_sparse(gamma)
7×7 Matrix{Int64}:
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  4  0  0  0  0  0
 0  0  4  0  0  0  0
 0  0  0  0  0  0  0

julia> full_from_sparse(phi)
7×7 Matrix{Int64}:
 1  1  0  0  0  0  0
 0  0  1  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  1  0  0  0
 0  0  0  0  0  1  0
 0  0  0  0  0  0  1
 0  0  0  0  0  0  1

julia> full_from_sparse(phi*phi)
7×7 Matrix{Int64}:
 1  1  1  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  1  0  0  0
 0  0  0  0  0  0  1
 0  0  0  0  0  0  1
 0  0  0  0  0  0  1

forman_comb_flow(lc::LefschetzComplex, fvf::Vector{Vector{String}})

Compute Forman's combinatorial flow and the associated chain homotopy.

This function returns matrix representations of Forman's combinatorial flow phi, and of the associated chain homotopy gamma.

forman_stab_flow(lc::LefschetzComplex, fvf::CellSubsets; maxit::Int=25)

Compute Forman's stabilized combinatorial flow and the associated chain homotopy which relates it to the identity.

This function returns matrix representations of Forman's stabilized combinatorial flow phiI, and of the associated chain homotopy gammaI. The third return argument is a boolean flag which indicates whether or not the combinatorial flow stabilized. If it did not, then either the underlying Forman vector field is not gradient (this is not checked!), or the maximal number of iterations has been reached. In the latter case, one has to pass the optional paramter maxit with a larger number of allowed iterations.

Example

julia> labels = ["a","b","c","d"];

julia> simplices = [["a","b"], ["b","c"], ["c","d"]];

julia> lc = create_simplicial_complex(labels, simplices, p=5);

julia> fvf = [["ab","b"], ["bc","c"]];

julia> phiI, gammaI, stabilized = forman_stab_flow(lc, fvf);

julia> stabilized
true

julia> full_from_sparse(gammaI)
7×7 Matrix{Int64}:
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  4  4  0  0  0  0
 0  0  4  0  0  0  0
 0  0  0  0  0  0  0

julia> full_from_sparse(phiI)
7×7 Matrix{Int64}:
 1  1  1  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  0  0  0  0
 0  0  0  1  0  0  0
 0  0  0  0  0  0  1
 0  0  0  0  0  0  1
 0  0  0  0  0  0  1

forman_gpaths(lc::LefschetzComplex, fvf::CellSubsets, x::Cell)

Find all Forman gradient paths starting at a source cell.

For the Forman gradient vector field fvf on the Lefschetz complex lc this function finds all maximal gradient paths starting at x. These are solution paths which consist exclusively of Forman vectors, i.e., they contain an even number of cells whose dimensions alternate between dim(x) and dim(x) + 1. Every cell of dimension dim(x) is an arrow source which is followed by its arrow target, while every cell of dimension dim(x) + 1 is an arrow target which is succeeded by a cell in its boundary which is the source of a different arrow, as long as such a cell exists.

forman_gpaths(lc::LefschetzComplex, fvf::CellSubsets,
                   x::Cell, y::Cell)

Find all Forman gradient paths between two cells.

For the Forman gradient vector field fvf on the Lefschetz complex lc this function finds all gradient paths between the cells x and y. The dimensions of these cells have to satisfy one of the following three conditions:

• dim(x) = dim(y) - 1: In this case the function returns all solution paths between x and y which consist entirely of Forman arrows. All the sources have the dimension of x, and the targets the dimension of y.
• dim(x) = dim(y): In this case the function returns all solution paths p between x and y for which p[1:end-1] is a Forman gradient path in the above sense, and p[end] lies in the boundary of p[end-1] and is different from the cell p[end-2].
• dim(x) = dim(y) + 1: In this case the function returns all solution paths p between x and y for which p[2:end-1] is a Forman gradient path in the sense of the first item, where p[2] lies in the boundary of p[1], and p[end] is contained in the boundary of p[end-1].

In all other cases an empty collection is returned.

forman_path_weight(lc::LefschetzComplex, path::Cells)

Compute the weight of a Forman gradient path.

For the Lefschetz complex lc this function computes the weight of the Forman gradient path given in path. It is expected that the dimensions of the first and the last cell in the path differ by at most 1. In case they have equal dimension, and the path has length larger than 1, the first cell has to be an arrow source.

forman_path_weight(lc::LefschetzComplex, paths::CellSubsets)

Accumulated weight of a collection of Forman gradient paths.

For the Lefschetz complex lc this function computes the sum of the weights of the collection of Forman gradient paths given in paths.

chain_vector(lc::LefschetzComplex, chcells::Vector{Int})

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has a 1 in every cell location indicated by the entries in the input argument chcells.

chain_vector(lc::LefschetzComplex, chcells::Vector{String})

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has a 1 for every cell indicated by the labels listed in the input argument chcells.

chain_vector(lc::LefschetzComplex, chcell::Int)

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has a 1 at the cell index specified in the second argument.

chain_vector(lc::LefschetzComplex, chcell::String)

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has a 1 at the cell specified by the second argument.

chain_vector(lc::LefschetzComplex, chcells::Vector{Int}, chcoeff)

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has the entry chcoeff[k] in the chcells[k]-th row. In other words, it constructs the vector representation of the chain consisting of the cells specified in chcells, with coefficients as specified in chcoeff.

chain_vector(lc::LefschetzComplex, chcells::Vector{String}, chcoeff)

Create a sparse vector representing a chain.

This function returns a sparse matrix in the form of a column vector, which has the entry chcoeff[k] in the row corresponding to the cell with label chcells[k]. In other words, it constructs the vector representation of the chain consisting of the cells specified in chcells, with coefficients as specified in chcoeff.

chain_vector(lc::LefschetzComplex, chcell::Int, chcoeff)

Create a sparse vector representing a chain.

This short-cut method specifies a chain consiting of one cell and its coefficient. The cell is given as its index.

chain_vector(lc::LefschetzComplex, chcell::String, chcoeff)

Create a sparse vector representing a chain.

This short-cut method specifies a chain consiting of one cell and its coefficient. The cell is given via its label.

chain_support(lc::LefschetzComplex, cvec::SparseMatrix; coeff::Bool=false)

Determine the support of a chain given as a sparse vector.

This function returns the support of a chain, given in the form of a sparse vector. In the default usage, the function returns a Vector{String} which contains the labels of all the cells which have nonzero coefficients in the chain. If one passes the optional parameter coeff=true, then the function returns two arguments: In addition to the vector of labels as above, it also returns the vector of associated coefficients.