code: def _split_operations(ops, params, split_indices, num_tapes):
      """
      Given a list of operators, return a list (with length ``num_tapes``) containing lists
      of new operators with the parameters at the given indices unbatched.
  
      Args:
          ops (Sequence[.Operator]): list of operators to split
          params (Sequence[TensorLike]): list of parameters which may have a batch dimension.
              The size of this list must be the total number of parameters in the ``ops`` list.
          split_indices (Sequence[int]): the parameter indices that need to be unbatched. The
              index of a parameter, say ``p``, is defined to be its index in the list
              ``[p for op in ops for p in op.data]``. If any parameter of an operator has an index
              contained in ``split_indices``, then a new operator is created using the corresponding
              entry of ``params``. Otherwise, the original operator is used.
          num_tapes (int): the number of new tapes to create, which is also equal to the batch size.
      """
      # for some reason pylint thinks "qml.ops" is a set
      # pylint: disable=no-member
      new_ops = [[] for _ in range(num_tapes)]
      idx = 0
  
      for op in ops:
          # determine if any parameters of the operator are batched
          if any(
              i in split_indices for i in range(idx, idx + len(op.data))
          ):
              for b in range(num_tapes):
                  new_params = tuple(
                      params[i][b] if i in split_indices else params[i]
                      for i in range(idx, idx + len(op.data))
                  )
                  new_op = qml.ops.functions.bind_new_parameters(
                      op, new_params
                  )
                  new_ops[b].append(new_op)
          else:
              # no batching in the operator; don't copy
              for b in range(num_tapes):
                  new_ops[b].append(op)
  
          idx += len(op.data)
  
      return new_ops
  
imports: from typing import Callable, Sequence
  import pennylane
  from .core import transform
label_desc: Use image node_id 2 for calling a global function with example usage: _split_operations(ops, params, split_indices, num_tapes) and returns: new_ops