Loading...
Searching...
No Matches
Witness complex

## Classes

class | Gudhi::witness_complex::Euclidean_strong_witness_complex< Kernel_ >
| Constructs strong witness complex for given sets of witnesses and landmarks in Euclidean space. More...
class | Gudhi::witness_complex::Euclidean_witness_complex< Kernel_ >
| Constructs (weak) witness complex for given sets of witnesses and landmarks in Euclidean space. More...
class | Gudhi::witness_complex::Strong_witness_complex< Nearest_landmark_table_ >
| Constructs strong witness complex for a given table of nearest landmarks with respect to witnesses. More...
class | Gudhi::witness_complex::Witness_complex< Nearest_landmark_table_ >
| Constructs (weak) witness complex for a given table of nearest landmarks with respect to witnesses. More...

## Detailed Description

Author
  Siargey Kachanovich

Witness complex representation

# Definitions

Witness complex is a simplicial complex defined on two sets of points in \(\mathbb{R}^D\):

- \(W\) set of witnesses and
- \(L\) set of landmarks.

Even though often the set of landmarks \(L\) is a subset of the set of witnesses \( W\), it is not a requirement for the current implementation.

Landmarks are the vertices of the simplicial complex and witnesses help to decide on which simplices are inserted via a predicate "is witnessed".

De Silva and Carlsson in their paper [de2004topological] differentiate weak witnessing and strong witnessing:

- weak: \( \sigma \subset L \) is witnessed by \( w \in W\) if \( \forall l \in \sigma,\ \forall l' \in \mathbf{L \setminus \sigma},\ d(w,l) \leq d(w,l') \)
- strong: \( \sigma \subset L \) is witnessed by \( w \in W\) if \( \forall l \in \sigma,\ \forall l' \in \mathbf{L},\ d(w,l) \leq d(w,l') \)

where \( d(.,.) \) is a distance function.

Both definitions can be relaxed by a real value \(\alpha\):

- weak: \( \sigma \subset L \) is \(\alpha\)-witnessed by \( w \in W\) if \( \forall l \in \sigma,\ \forall l' \in \mathbf{L \setminus \sigma},\ d(w,l)^2 \leq d(w,l')^2 + \alpha^2 \)
- strong: \( \sigma \subset L \) is \(\alpha\)-witnessed by \( w \in W\) if \( \forall l \in \sigma,\ \forall l' \in \mathbf{L},\ d(w,l)^2 \leq d(w,l')^2 + \alpha^2 \)

which leads to definitions of weak relaxed witness complex (or just relaxed witness complex for short) and strong relaxed witness complex respectively.

Strongly witnessed simplex

In particular case of 0-relaxation, weak complex corresponds to witness complex introduced in [de2004topological], whereas 0-relaxed strong witness complex consists of just vertices and is not very interesting. Hence for small relaxation weak version is preferable. However, to capture the homotopy type (for example using Gudhi::persistent_cohomology::Persistent_cohomology) it is often necessary to work with higher filtration values. In this case strong relaxed witness complex is faster to compute and offers similar results.

# Implementation

The two complexes described above are implemented in the corresponding classes

- Gudhi::witness_complex::Witness_complex
- Gudhi::witness_complex::Euclidean_witness_complex
- Gudhi::witness_complex::Strong_witness_complex
- Gudhi::witness_complex::Euclidean_strong_witness_complex

The construction of the Euclidean versions of complexes follow the same scheme:

1. Construct a search tree on landmarks (for that Gudhi::spatial_searching::Kd_tree_search is used internally).
2. Construct lists of nearest landmarks for each witness (special structure Gudhi::witness_complex::Active_witness is used internally).
3. Construct the witness complex for nearest landmark lists.

In the non-Euclidean classes, the lists of nearest landmarks are supposed to be given as input.

The constructors take on the steps 1 and 2, while the function 'create_complex' executes the step 3.

# Example 1: Constructing weak relaxed witness complex from an off file

Let's start with a simple example, which reads an off point file and computes a weak witness complex.

#include <gudhi/Simplex_tree.h>
#include <gudhi/Euclidean_witness_complex.h>
#include <gudhi/pick_n_random_points.h>
#include <gudhi/Points_off_io.h>
#include <CGAL/Epick_d.h>
#include <string>
#include <vector>
typedef CGAL::Epick_d<CGAL::Dynamic_dimension_tag> K;
typedef typename K::Point_d Point_d;
typedef typename Gudhi::witness_complex::Euclidean_witness_complex<K> Witness_complex;
typedef std::vector< Vertex_handle > typeVectorVertex;
typedef std::vector< Point_d > Point_vector;
int main(int argc, char * const argv[]) {
std::string file_name = argv[1];
int nbL = atoi(argv[2]), lim_dim = atoi(argv[4]);
double alpha2 = atof(argv[3]);
Gudhi::Simplex_tree<> simplex_tree;
// Read the point file
Point_vector point_vector, landmarks;
Gudhi::Points_off_reader<Point_d> off_reader(file_name);
point_vector = Point_vector(off_reader.get_point_cloud());
// Choose landmarks (one can choose either of the two methods below)
// Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
Gudhi::subsampling::choose_n_farthest_points(K().squared_distance_d_object(), point_vector, nbL,
Gudhi::subsampling::random_starting_point, std::back_inserter(landmarks));
// Compute witness complex
Witness_complex witness_complex(landmarks, point_vector);
witness_complex.create_complex(simplex_tree, alpha2, lim_dim);
}
Gudhi::Points_off_reader
OFF file reader implementation in order to read points from an OFF file.
Definition Points_off_io.h:122
Gudhi::Simplex_tree
Simplex Tree data structure for representing simplicial complexes.
Definition Simplex_tree.h:98
Gudhi::witness_complex::Euclidean_witness_complex
Constructs (weak) witness complex for given sets of witnesses and landmarks in Euclidean space.
Definition Euclidean_witness_complex.h:53
Gudhi::subsampling::choose_n_farthest_points
void choose_n_farthest_points(Distance dist, Point_range const &input_pts, std::size_t final_size, std::size_t starting_point, PointOutputIterator output_it, DistanceOutputIterator dist_it={})
Subsample by an iterative, greedy strategy.
Definition choose_n_farthest_points.h:75
Gudhi::subsampling::random_starting_point
@ random_starting_point
Definition choose_n_farthest_points.h:43

# Example2: Computing persistence using strong relaxed witness complex

Here is an example of constructing a strong witness complex filtration and computing persistence on it:

/* This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
* See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
* Author(s): Siargey Kachanovich
*
* Copyright (C) 2016 Inria
*
* Modification(s):
* - YYYY/MM Author: Description of the modification
*/
#include <gudhi/Simplex_tree.h>
#include <gudhi/Euclidean_strong_witness_complex.h>
#include <gudhi/Persistent_cohomology.h>
#include <gudhi/Points_off_io.h>
#include <gudhi/pick_n_random_points.h>
#include <gudhi/choose_n_farthest_points.h>
#include <boost/program_options.hpp>
#include <CGAL/Epick_d.h>
#include <string>
#include <vector>
#include <limits> // infinity
using K = CGAL::Epick_d<CGAL::Dynamic_dimension_tag>;
using Point_d = K::Point_d;
using Point_vector = std::vector<Point_d>;
using Strong_witness_complex = Gudhi::witness_complex::Euclidean_strong_witness_complex<K>;
using SimplexTree = Gudhi::Simplex_tree<>;
using Filtration_value = SimplexTree::Filtration_value;
using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<SimplexTree, Field_Zp>;
void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence);
int main(int argc, char* argv[]) {
std::string file_name;
std::string filediag;
Filtration_value max_squared_alpha;
int p, nbL, lim_d;
Filtration_value min_persistence;
SimplexTree simplex_tree;
program_options(argc, argv, nbL, file_name, filediag, max_squared_alpha, p, lim_d, min_persistence);
// Extract the points from the file file_name
Point_vector witnesses, landmarks;
Gudhi::Points_off_reader<Point_d> off_reader(file_name);
if (!off_reader.is_valid()) {
std::cerr << "Witness complex - Unable to read file " << file_name << "\n";
exit(-1); // ----- >>
}
witnesses = Point_vector(off_reader.get_point_cloud());
std::clog << "Successfully read " << witnesses.size() << " points.\n";
std::clog << "Ambient dimension is " << witnesses[0].dimension() << ".\n";
// Choose landmarks (decomment one of the following two lines)
// Gudhi::subsampling::pick_n_random_points(point_vector, nbL, std::back_inserter(landmarks));
Gudhi::subsampling::choose_n_farthest_points(K().squared_distance_d_object(), witnesses, nbL,
Gudhi::subsampling::random_starting_point,
std::back_inserter(landmarks));
// Compute witness complex
Strong_witness_complex strong_witness_complex(landmarks, witnesses);
strong_witness_complex.create_complex(simplex_tree, max_squared_alpha, lim_d);
std::clog << "The complex contains " << simplex_tree.num_simplices() << " simplices \n";
std::clog << " and has dimension " << simplex_tree.dimension() << " \n";
// Sort the simplices in the order of the filtration
simplex_tree.initialize_filtration();
// Compute the persistence diagram of the complex
Persistent_cohomology pcoh(simplex_tree);
// initializes the coefficient field for homology
pcoh.init_coefficients(p);
pcoh.compute_persistent_cohomology(min_persistence);
// Output the diagram in filediag
if (filediag.empty()) {
pcoh.output_diagram();
} else {
std::ofstream out(filediag);
pcoh.output_diagram(out);
out.close();
}
return 0;
}
void program_options(int argc, char* argv[], int& nbL, std::string& file_name, std::string& filediag,
Filtration_value& max_squared_alpha, int& p, int& dim_max, Filtration_value& min_persistence) {
namespace po = boost::program_options;
po::options_description hidden("Hidden options");
hidden.add_options()("input-file", po::value<std::string>(&file_name),
"Name of file containing a point set in off format.");
po::options_description visible("Allowed options", 100);
Filtration_value default_alpha = std::numeric_limits<Filtration_value>::infinity();
visible.add_options()("help,h", "produce help message")("landmarks,l", po::value<int>(&nbL),
"Number of landmarks to choose from the point cloud.")(
"output-file,o", po::value<std::string>(&filediag)->default_value(std::string()),
"Name of file in which the persistence diagram is written. Default print in standard output")(
"max-sq-alpha,a", po::value<Filtration_value>(&max_squared_alpha)->default_value(default_alpha),
"Maximal squared relaxation parameter.")(
"field-charac,p", po::value<int>(&p)->default_value(11),
"Characteristic p of the coefficient field Z/pZ for computing homology.")(
"min-persistence,m", po::value<Filtration_value>(&min_persistence)->default_value(0),
"Minimal lifetime of homology feature to be recorded. Default is 0. Enter a negative value to see zero length "
"intervals")("cpx-dimension,d", po::value<int>(&dim_max)->default_value(std::numeric_limits<int>::max()),
"Maximal dimension of the strong witness complex we want to compute.");
po::positional_options_description pos;
pos.add("input-file", 1);
po::options_description all;
all.add(visible).add(hidden);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(all).positional(pos).run(), vm);
po::notify(vm);
if (vm.count("help") || !vm.count("input-file")) {
std::clog << std::endl;
std::clog << "Compute the persistent homology with coefficient field Z/pZ \n";
std::clog << "of a Strong witness complex defined on a set of input points.\n \n";
std::clog << "The output diagram contains one bar per line, written with the convention: \n";
std::clog << " p dim b d \n";
std::clog << "where dim is the dimension of the homological feature,\n";
std::clog << "b and d are respectively the birth and death of the feature and \n";
std::clog << "p is the characteristic of the field Z/pZ used for homology coefficients." << std::endl << std::endl;
std::clog << "Usage: " << argv[0] << " [options] input-file" << std::endl << std::endl;
std::clog << visible << std::endl;
exit(-1);
}
}
Gudhi::Simplex_tree::Filtration_value
Options::Filtration_value Filtration_value
Type for the value of the filtration function.
Definition Simplex_tree.h:105
Gudhi::Simplex_tree::initialize_filtration
void initialize_filtration(bool ignore_infinite_values=false) const
Initializes the filtration cache, i.e. sorts the simplices according to their order in the filtration...
Definition Simplex_tree.h:1200
Gudhi::Simplex_tree::num_simplices
size_t num_simplices() const
Returns the number of simplices in the simplex_tree.
Definition Simplex_tree.h:791
Gudhi::persistent_cohomology::Field_Zp
Structure representing the coefficient field .
Definition Field_Zp.h:27
Gudhi::persistent_cohomology::Persistent_cohomology
Computes the persistent cohomology of a filtered complex.
Definition Persistent_cohomology.h:54
Gudhi::witness_complex::Euclidean_strong_witness_complex
Constructs strong witness complex for given sets of witnesses and landmarks in Euclidean space.
Definition Euclidean_strong_witness_complex.h:51

# Example3: Computing relaxed witness complex persistence from a distance matrix

In this example we compute the relaxed witness complex persistence from a given matrix of closest landmarks to each witness. Each landmark is given as the couple (index, distance).

#define BOOST_PARAMETER_MAX_ARITY 12
#include <gudhi/Simplex_tree.h>
#include <gudhi/Witness_complex.h>
#include <gudhi/Persistent_cohomology.h>
#include <iostream>
#include <fstream>
#include <utility>
#include <string>
#include <vector>
int main(int argc, char * const argv[]) {
using Nearest_landmark_range = std::vector<std::pair<std::size_t, double>>;
using Nearest_landmark_table = std::vector<Nearest_landmark_range>;
using Witness_complex = Gudhi::witness_complex::Witness_complex<Nearest_landmark_table>;
using Simplex_tree = Gudhi::Simplex_tree<>;
using Field_Zp = Gudhi::persistent_cohomology::Field_Zp;
using Persistent_cohomology = Gudhi::persistent_cohomology::Persistent_cohomology<Simplex_tree, Field_Zp>;
Simplex_tree simplex_tree;
// Example contains 5 witnesses and 5 landmarks
Nearest_landmark_table nlt = {
{{0, 0.0}, {1, 0.1}, {2, 0.2}, {3, 0.3}, {4, 0.4}}, // witness 0
{{1, 0.0}, {2, 0.1}, {3, 0.2}, {4, 0.3}, {0, 0.4}}, // witness 1
{{2, 0.0}, {3, 0.1}, {4, 0.2}, {0, 0.3}, {1, 0.4}}, // witness 2
{{3, 0.0}, {4, 0.1}, {0, 0.2}, {1, 0.3}, {2, 0.4}}, // witness 3
{{4, 0.0}, {0, 0.1}, {1, 0.2}, {2, 0.3}, {3, 0.4}} // witness 4
};
/* distance(witness3, landmark3) is 0, distance(witness3, landmark4) is 0.1, etc. */
Witness_complex witness_complex(nlt);
witness_complex.create_complex(simplex_tree, .41);
std::clog << "Number of simplices: " << simplex_tree.num_simplices() << std::endl;
Persistent_cohomology pcoh(simplex_tree);
// initializes the coefficient field for homology
pcoh.init_coefficients(11);
pcoh.compute_persistent_cohomology(-0.1);
pcoh.output_diagram();
}
Gudhi::witness_complex::Witness_complex
Constructs (weak) witness complex for a given table of nearest landmarks with respect to witnesses.
Definition Witness_complex.h:38