code: def cholesky(a, lower=False):
      """
      Cholesky decomposition.
  
      Return the Cholesky decomposition, `L * L.H`, of the square matrix `a`,
      where `L` is lower-triangular and .H is the conjugate transpose operator
      (which is the ordinary transpose if `a` is real-valued).  `a` must be
      Hermitian (symmetric if real-valued) and positive-definite.  Only `L` is
      actually returned.
  
      Parameters
      ----------
      a : (..., M, M) array_like
          Hermitian (symmetric if all elements are real), positive-definite
          input matrix.
      lower : bool
          Whether to compute the upper or lower triangular Cholesky
          factorization.  Default is upper-triangular.
  
      Returns
      -------
      L : (..., M, M) array_like
          Upper or lower-triangular Cholesky factor of `a`.
  
      Raises
      ------
      LinAlgError
         If the decomposition fails, for example, if `a` is not
         positive-definite.
  
      Notes
      -----
  
      Broadcasting rules apply, see the `mt.linalg` documentation for
      details.
  
      The Cholesky decomposition is often used as a fast way of solving
  
      .. math:: A \\mathbf{x} = \\mathbf{b}
  
      (when `A` is both Hermitian/symmetric and positive-definite).
  
      First, we solve for :math:`\\mathbf{y}` in
  
      .. math:: L \\mathbf{y} = \\mathbf{b},
  
      and then for :math:`\\mathbf{x}` in
  
      .. math:: L.H \\mathbf{x} = \\mathbf{y}.
  
      Examples
      --------
      >>> import mars.tensor as mt
  
      >>> A = mt.array([[1,-2j],[2j,5]])
      >>> A.execute()
      array([[ 1.+0.j,  0.-2.j],
             [ 0.+2.j,  5.+0.j]])
      >>> L = mt.linalg.cholesky(A, lower=True)
      >>> L.execute()
      array([[ 1.+0.j,  0.+0.j],
             [ 0.+2.j,  1.+0.j]])
      >>> mt.dot(L, L.T.conj()).execute() # verify that L * L.H = A
      array([[ 1.+0.j,  0.-2.j],
             [ 0.+2.j,  5.+0.j]])
      >>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
      >>> mt.linalg.cholesky(A, lower=True).execute()
      array([[ 1.+0.j,  0.+0.j],
             [ 0.+2.j,  1.+0.j]])
  
      """
      a = astensor(a)
  
      if a.ndim != 2:  # pragma: no cover
          raise LinAlgError(
              f"{a.ndim}-dimensional array given. Tensor must be two-dimensional"
          )
      if a.shape[0] != a.shape[1]:  # pragma: no cover
          raise LinAlgError("Input must be square")
  
      cho = np.linalg.cholesky(
          np.array([[1, 2], [2, 5]], dtype=a.dtype)
      )
  
      op = TensorCholesky(lower=lower, dtype=cho.dtype)
      return op(a)
  
imports: import numpy
  from numpy.linalg import LinAlgError
  from ...serialization.serializables import KeyField, BoolField
  from ...None import opcodes
  from ...core import recursive_tile
  from ...utils import has_unknown_shape
  from ..operands import TensorHasInput, TensorOperand, TensorOperandMixin
  from ..datasource import tensor
  from ..core import TensorOrder
  from ..array_utils import as_same_device, device
label_desc: Use image node_id 1 for calling a global function with example usage: cholesky(a, lower) and returns: op