code: def split(
      x: paddle.Tensor,
      /,
      *,
      copy: Optional[bool] = None,
      num_or_size_splits: Optional[
          Union[int, List[int], paddle.Tensor]
      ] = None,
      axis: Optional[int] = 0,
      with_remainder: Optional[bool] = False,
  ) -> List[paddle.Tensor]:
      if x.shape == ():
          if num_or_size_splits is not None and num_or_size_splits != 1:
              raise ivy.utils.exceptions.IvyException(
                  "input array had no shape, but num_sections specified was"
                  f" {num_or_size_splits}"
              )
          return [x]
      if num_or_size_splits is None:
          num_or_size_splits = x.shape[axis]
      elif isinstance(num_or_size_splits, paddle.Tensor):
          num_or_size_splits = num_or_size_splits.cast("int32")
          num_or_size_splits = num_or_size_splits.tolist()
      elif isinstance(num_or_size_splits, int):
          num_chunks = x.shape[axis] // num_or_size_splits
          remainder = x.shape[axis] % num_or_size_splits
          if remainder != 0:
              if with_remainder:
                  num_or_size_splits = [
                      num_or_size_splits
                  ] * num_chunks + [remainder]
              else:
                  raise ivy.utils.exceptions.IvyException(
                      "Split size is not compatible with input shape"
                  )
  
      if isinstance(num_or_size_splits, (list, tuple)):
          if sum(num_or_size_splits) < x.shape[axis]:
              num_or_size_splits + type(num_or_size_splits)([-1])
          elif sum(num_or_size_splits) > x.shape[axis]:
              raise ivy.utils.exceptions.IvyException(
                  "total split size is not compatible with input shape,"
                  f" got {sum(num_or_size_splits)} which is more than x.shape[axis]"
              )
  
      if paddle.is_complex(x):
          imag_list = paddle.split(x.imag(), num_or_size_splits, axis)
          real_list = paddle.split(x.real(), num_or_size_splits, axis)
          return [
              paddle.complex(a, b) for a, b in zip(real_list, imag_list)
          ]
      return paddle.split(x, num_or_size_splits, axis)
  
imports: from numbers import Number
  from typing import Union, Optional, Tuple, List, Sequence, Iterable
  import math
  import paddle
  import ivy
  import ivy.functional.backends.paddle
  from ivy.func_wrapper import with_unsupported_device_and_dtypes, with_unsupported_dtypes, with_supported_dtypes
  from .None import backend_version
  from ...ivy.manipulation import _calculate_out_shape
label_desc: Use image node_id 10 for calling a global function with example usage: split() and returns: paddle, list, unknown