docs: def backward_committor(T, A, B, mu=None):
      r"""Backward committor between given sets.
  
      The backward committor u(x) between sets A and B is the
      probability for the chain starting in x to have come from A last
      rather than from B.
  
      Parameters
      ----------
      T : (M, M) ndarray
          Transition matrix
      A : array_like
          List of integer state labels for set A
      B : array_like
          List of integer state labels for set B
      mu : (M, ) ndarray (optional)
          Stationary vector
  
      Returns
      -------
      u : (M, ) ndarray
          Vector of forward committor probabilities
  
      Notes
      -----
      The forward committor is a solution to the following
      boundary-value problem
  
      .. math::
  
          \sum_j K_{ij} \pi_{j} u_{j}=0    for i in X\(A u B) (I)
                                    u_{i}=1    for i \in A        (II)
                                    u_{i}=0    for i \in B        (III)
  
      with adjoint of the generator matrix K=(D_pi(P-I))'.
  
      """
      X = set(range(T.shape[0]))
      A = set(A)
      B = set(B)
      AB = A.intersection(B)
      notAB = X.difference(A).difference(B)
      if len(AB) > 0:
          raise ValueError("Sets A and B have to be disjoint")
      if mu is None:
          mu = stationary_distribution(T)
      K = np.transpose(mu[:, np.newaxis] * (T - np.eye(T.shape[0])))
  
      """Assemble left-hand side W for linear system"""
      """Equation (I)"""
      W = 1.0 * K
      """Equation (II)"""
      W[list(A), :] = 0.0
      W[list(A), list(A)] = 1.0
      """Equation (III)"""
      W[list(B), :] = 0.0
      W[list(B), list(B)] = 1.0
  
      """Assemble right-hand side r for linear system"""
      """Equation (I)+(III)"""
      r = np.zeros(T.shape[0])
      """Equation (II)"""
      r[list(A)] = 1.0
  
      u = solve(W, r)
  
      return u