code: def mode_dot(tensor, matrix_or_vector, mode, transpose=False):
      """n-mode product of a tensor and a matrix or vector at the specified mode
  
      Mathematically: :math:`\\text{tensor} \\times_{\\text{mode}} \\text{matrix or vector}`
  
  
      Parameters
      ----------
      tensor : ndarray
          tensor of shape ``(i_1, ..., i_k, ..., i_N)``
      matrix_or_vector : ndarray
          1D or 2D array of shape ``(J, i_k)`` or ``(i_k, )``
          matrix or vectors to which to n-mode multiply the tensor
      mode : int
      transpose : bool, default is False
          If True, the matrix is transposed.
          For complex tensors, the conjugate transpose is used.
  
      Returns
      -------
      ndarray
          `mode`-mode product of `tensor` by `matrix_or_vector`
          * of shape :math:`(i_1, ..., i_{k-1}, J, i_{k+1}, ..., i_N)` if matrix_or_vector is a matrix
          * of shape :math:`(i_1, ..., i_{k-1}, i_{k+1}, ..., i_N)` if matrix_or_vector is a vector
  
      See also
      --------
      multi_mode_dot : chaining several mode_dot in one call
      """
      # the mode along which to fold might decrease if we take product with a vector
      fold_mode = mode
      new_shape = list(tensor.shape)
  
      if T.ndim(matrix_or_vector) == 2:  # Tensor times matrix
          # Test for the validity of the operation
          dim = 0 if transpose else 1
          if matrix_or_vector.shape[dim] != tensor.shape[mode]:
              raise ValueError(
                  f"shapes {tensor.shape} and {matrix_or_vector.shape} not aligned in mode-{mode} multiplication: "
                  f"{tensor.shape[mode]} (mode {mode}) != {matrix_or_vector.shape[dim]} (dim 1 of matrix)"
              )
  
          if transpose:
              matrix_or_vector = T.conj(T.transpose(matrix_or_vector))
  
          new_shape[mode] = matrix_or_vector.shape[0]
          vec = False
  
      elif T.ndim(matrix_or_vector) == 1:  # Tensor times vector
          if matrix_or_vector.shape[0] != tensor.shape[mode]:
              raise ValueError(
                  f"shapes {tensor.shape} and {matrix_or_vector.shape} not aligned for mode-{mode} multiplication: "
                  f"{tensor.shape[mode]} (mode {mode}) != {matrix_or_vector.shape[0]} (vector size)"
              )
          if len(new_shape) > 1:
              new_shape.pop(mode)
          else:
              new_shape = ()
          vec = True
  
      else:
          raise ValueError(
              "Can only take n_mode_product with a vector or a matrix."
              f"Provided array of dimension {T.ndim(matrix_or_vector)} not in [1, 2]."
          )
  
      res = T.dot(matrix_or_vector, unfold(tensor, mode))
  
      if vec:  # We contracted with a vector, leading to a vector
          return vec_to_tensor(res, shape=new_shape)
      else:  # tensor times vec: refold the unfolding
          return fold(res, fold_mode, new_shape)
  
imports: from ...None import backend
  from ...None import unfold, fold, vec_to_tensor
label_desc: Use image node_id 1 for calling a global function with example usage: mode_dot(tensor, matrix_or_vector, mode, transpose) and returns: vec_to_tensor, fold