<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def apply_matrix_to_slices( target: np.ndarray, matrix: np.ndarray, slices: List[_TSlice], *, out: Optional[np.ndarray] = None) -> np.ndarray: """Left-multiplies an NxN matrix onto N slices of a numpy array. Example: The 4x4 matrix of a fractional SWAP gate can be expressed as [ 1 ] [ X**t ] [ 1 ] Where X is the 2x2 Pauli X gate and t is the power of the swap with t=1 being a full swap. X**t is a power of the Pauli X gate's matrix. Applying the fractional swap is equivalent to applying a fractional X within the inner 2x2 subspace; the rest of the matrix is identity. This can be expressed using `apply_matrix_to_slices` as follows: def fractional_swap(target):
 assert target.shape == (4,) return apply_matrix_to_slices( target=target, matrix=cirq.unitary(cirq.X**t), slices=[1, 2] ) Args: target: The input array with slices that need to be left-multiplied. matrix: The linear operation to apply to the subspace defined by the slices. slices: The parts of the tensor that correspond to the "vector entries" that the matrix should operate on. May be integers or complicated multi-dimensional slices into a tensor. The slices must refer to non-overlapping sections of the input all with the same shape. out: Where to write the output. If not specified, a new numpy array is created, with the same shape and dtype as the target, to store the output. Returns: The transformed array. """

    # Validate arguments.
    if out is target:
        raise ValueError("Can't write output over the input.")
    if matrix.shape != (len(slices), len(slices)):
        raise ValueError("matrix.shape != (len(slices), len(slices))")

    # Fill in default values and prepare space.
    if out is None:
        out = np.copy(target)
    else:
        out[...] = target[...]

    # Apply operation.
    for i, s_i in enumerate(slices):
        out[s_i] *= matrix[i, i]
        for j, s_j in enumerate(slices):
            if i != j:
                out[s_i] += target[s_j] * matrix[i, j]

    return out