docs: def _conditional(Xnew, feat, kern, f, *, full_cov=False, full_output_cov=False, q_sqrt=None, white=False):
      """
      Single-output GP conditional.
  
      The covariance matrices used to calculate the conditional have the following shape:
      - Kuu: M x M
      - Kuf: M x N
      - Kff: N or N x N
  
      Further reference
      -----------------
      - See `gpflow.conditionals._conditional` (below) for a detailed explanation of
        conditional in the single-output case.
      - See the multiouput notebook for more information about the multiouput framework.
  
      Parameters
      ----------
      :param Xnew: data matrix, size N x D.
      :param feat: gpflow.InducingFeature object
      :param kern: gpflow kernel object.
      :param f: data matrix, M x R
      :param full_cov: return the covariance between the datapoints
      :param full_output_cov: return the covariance between the outputs.
       Note: as we are using a single-output kernel with repetitions these covariances will be zero.
      :param q_sqrt: matrix of standard-deviations or Cholesky matrices,
          size M x R or R x M x M.
      :param white: boolean of whether to use the whitened representation
      :return:
          - mean:     N x R
          - variance: N x R, R x N x N, N x R x R or N x R x N x R
          Please see `gpflow.conditional._expand_independent_outputs` for more information
          about the shape of the variance, depending on `full_cov` and `full_output_cov`.
      """
      logger.debug("Conditional: Inducing Feature - Kernel")
      Kmm = Kuu(feat, kern, jitter=settings.numerics.jitter_level)  # M x M
      Kmn = Kuf(feat, kern, Xnew)  # M x N
      Knn = kern.K(Xnew) if full_cov else kern.Kdiag(Xnew)
  
      fmean, fvar = base_conditional(Kmn, Kmm, Knn, f, full_cov=full_cov,
                                     q_sqrt=q_sqrt, white=white)  # N x R,  R x N x N or N x R
      return fmean, _expand_independent_outputs(fvar, full_cov, full_output_cov)