cirq.apply_matrix_to_slices

cirq.apply_matrix_to_slices(target: numpy.ndarray, matrix: numpy.ndarray, slices: List[Union[int, slice, ellipsis, Sequence[Union[int, slice, ellipsis]]]], *, out: Optional[numpy.ndarray] = None) → numpy.ndarray[source]

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]
    )
Parameters:
  • 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.