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 [22] 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 [22], 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(), 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);
}

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(), 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 std::clog")(
      "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);
  }
}

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();
}