code: def internal_minimum_spanning_tree(mr_distances):
      """
      Compute the 'internal' minimum spanning tree given a matrix of mutual
      reachability distances. Given a minimum spanning tree the 'internal'
      graph is the subgraph induced by vertices of degree greater than one.
  
      Parameters
      ----------
      mr_distances : array (cluster_size, cluster_size)
          The pairwise mutual reachability distances, inferred to be the edge
          weights of a complete graph. Since MSTs are computed per cluster
          this is the all-points-mutual-reacability for points within a single
          cluster.
  
      Returns
      -------
      internal_nodes : array
          An array listing the indices of the internal nodes of the MST
  
      internal_edges : array (?, 3)
          An array of internal edges in weighted edge list format; that is
          an edge is an array of length three listing the two vertices
          forming the edge and weight of the edge.
  
      References
      ----------
      Moulavi, D., Jaskowiak, P.A., Campello, R.J., Zimek, A. and Sander, J.,
      2014. Density-Based Clustering Validation. In SDM (pp. 839-847).
      """
      single_linkage_data = mst_linkage_core(mr_distances)
      min_span_tree = single_linkage_data.copy()
      for index, row in enumerate(min_span_tree[1:], 1):
          candidates = np.where(
              isclose(mr_distances[int(row[1])], row[2])
          )[0]
          candidates = np.intersect1d(
              candidates, single_linkage_data[:index, :2].astype(int)
          )
          candidates = candidates[candidates != row[1]]
          assert len(candidates) > 0
          row[0] = candidates[0]
  
      vertices = np.arange(mr_distances.shape[0])[
          np.bincount(min_span_tree.T[:2].flatten().astype(np.intp)) > 1
      ]
      if not len(vertices):
          vertices = [0]
      # A little "fancy" we select from the flattened array reshape back
      # (Fortran format to get indexing right) and take the product to do an and
      # then convert back to boolean type.
      edge_selection = np.prod(
          np.in1d(min_span_tree.T[:2], vertices).reshape(
              (min_span_tree.shape[0], 2), order="F"
          ),
          axis=1,
      ).astype(bool)
  
      # Density sparseness is not well defined if there are no
      # internal edges (as per the referenced paper). However
      # MATLAB code from the original authors simply selects the
      # largest of *all* the edges in the case that there are
      # no internal edges, so we do the same here
      if np.any(edge_selection):
          # If there are any internal edges, then subselect them out
          edges = min_span_tree[edge_selection]
      else:
          # If there are no internal edges then we want to take the
          # max over all the edges that exist in the MST, so we simply
          # do nothing and return all the edges in the MST.
          edges = min_span_tree.copy()
  
      return vertices, edges
  
file_path: hdbscan/hdbscan/validity.py
imports: import numpy
  from sklearn.metrics import pairwise_distances
  from scipy.spatial.distance import cdist
  from ._hdbscan_linkage import mst_linkage_core
  from .hdbscan_ import isclose
label_desc: Use image node_id 4 for calling a global function with example usage: internal_minimum_spanning_tree(mr_distances) and returns: vertices,  edges