code: def null_space(
      M,
      k,
      k_skip=1,
      eigen_solver="arpack",
      tol=1e-6,
      max_iter=100,
      random_state=None,
  ):
      """
      Find the null space of a matrix M.
  
      Parameters
      ----------
      M : {array, matrix, sparse matrix, LinearOperator}
          Input covariance matrix: should be symmetric positive semi-definite
  
      k : int
          Number of eigenvalues/vectors to return
  
      k_skip : int, default=1
          Number of low eigenvalues to skip.
  
      eigen_solver : {'auto', 'arpack', 'dense'}, default='arpack'
          auto : algorithm will attempt to choose the best method for input data
          arpack : use arnoldi iteration in shift-invert mode.
                      For this method, M may be a dense matrix, sparse matrix,
                      or general linear operator.
                      Warning: ARPACK can be unstable for some problems.  It is
                      best to try several random seeds in order to check results.
          dense  : use standard dense matrix operations for the eigenvalue
                      decomposition.  For this method, M must be an array
                      or matrix type.  This method should be avoided for
                      large problems.
  
      tol : float, default=1e-6
          Tolerance for 'arpack' method.
          Not used if eigen_solver=='dense'.
  
      max_iter : int, default=100
          Maximum number of iterations for 'arpack' method.
          Not used if eigen_solver=='dense'
  
      random_state : int, RandomState instance, default=None
          Determines the random number generator when ``solver`` == 'arpack'.
          Pass an int for reproducible results across multiple function calls.
          See :term:`Glossary <random_state>`.
      """
      if eigen_solver == "auto":
          if M.shape[0] > 200 and k + k_skip < 10:
              eigen_solver = "arpack"
          else:
              eigen_solver = "dense"
  
      if eigen_solver == "arpack":
          v0 = _init_arpack_v0(M.shape[0], random_state)
          try:
              eigen_values, eigen_vectors = eigsh(
                  M,
                  k + k_skip,
                  sigma=0.0,
                  tol=tol,
                  maxiter=max_iter,
                  v0=v0,
              )
          except RuntimeError as e:
              raise ValueError(
                  "Error in determining null-space with ARPACK. Error message: "
                  "'%s'. Note that eigen_solver='arpack' can fail when the "
                  "weight matrix is singular or otherwise ill-behaved. In that "
                  "case, eigen_solver='dense' is recommended. See online "
                  "documentation for more information." % e
              ) from e
  
          return eigen_vectors[:, k_skip:], np.sum(
              eigen_values[k_skip:]
          )
      elif eigen_solver == "dense":
          if hasattr(M, "toarray"):
              M = M.toarray()
          eigen_values, eigen_vectors = eigh(
              M,
              subset_by_index=(k_skip, k + k_skip - 1),
              overwrite_a=True,
          )
          index = np.argsort(np.abs(eigen_values))
          return eigen_vectors[:, index], np.sum(eigen_values)
      else:
          raise ValueError(
              "Unrecognized eigen_solver '%s'" % eigen_solver
          )
  
imports: from numbers import Integral, Real
  import numpy
  from scipy.linalg import eigh, qr, solve, svd
  from scipy.sparse import csr_matrix, eye
  from scipy.sparse.linalg import eigsh
  from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin, _fit_context, _UnstableArchMixin
  from ..neighbors import NearestNeighbors
  from ..utils import check_array, check_random_state
  from ..utils._arpack import _init_arpack_v0
  from ..utils._param_validation import Interval, StrOptions
  from ..utils.extmath import stable_cumsum
  from ..utils.validation import FLOAT_DTYPES, check_is_fitted
label_desc: Use image node_id 3 for calling a global function with example usage: null_space(M, k, k_skip, eigen_solver, tol, max_iter, random_state) and returns: eigen_vectors,  np, eigen_vectors,  np