cirq.apply_matrix_to_slices

Left-multiplies an NxN matrix onto N slices of a numpy array.

cirq.apply_matrix_to_slices(
    target: np.ndarray,
    matrix: np.ndarray,
    slices: Sequence[_TSlice],
    *,
    out: (np.ndarray | None) = None
) -> np.ndarray

One example is that the 4x4 matrix of a fractional SWAP gate can be expressed as

\(\) \begin{bmatrix} 1 & & \ & X**t & \ & & 1 \ \end{bmatrix}

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]
    )

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.

The transformed array.

ValueError If out is target , or the matrix shaped does not match slices.