Source code for pennylane.ops.functions.matrix

# Copyright 2018-2021 Xanadu Quantum Technologies Inc.

# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at

# Unless required by applicable law or agreed to in writing, software
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
"""
This module contains the qml.matrix function.
"""
# pylint: disable=protected-access
import pennylane as qml

[docs]@qml.op_transform
def matrix(op, *, wire_order=None):
r"""The matrix representation of an operation or quantum circuit.

Args:
op (.Operator, pennylane.QNode, .QuantumTape, or Callable): An operator, quantum node, tape,
or function that applies quantum operations.
wire_order (Sequence[Any], optional): Order of the wires in the quantum circuit.
Defaults to the order in which the wires appear in the quantum function.

Returns:
tensor_like or function: Function which accepts the same arguments as the QNode or quantum
function. When called, this function will return the unitary matrix in the appropriate
autodiff framework (Autograd, TensorFlow, PyTorch, JAX) given its parameters.

**Example**

Given an instantiated operator, qml.matrix returns the matrix representation:

>>> op = qml.RX(0.54, wires=0)
>>> qml.matrix(op)
[[0.9637709+0.j         0.       -0.26673144j]
[0.       -0.26673144j 0.9637709+0.j        ]]

It can also be used in a functional form:

>>> matrix_fn = qml.matrix(qml.RX)
>>> matrix_fn(x, wires=0)
tensor([[0.9553+0.0000j, 0.0000-0.2955j],

In its functional form, it is fully differentiable with respect to gate arguments:

>>> loss = torch.real(torch.trace(matrix_fn(x, wires=0)))
>>> loss.backward()
tensor(-0.5910)

This operator transform can also be applied to QNodes, tapes, and quantum functions
that contain multiple operations; see Usage Details below for more details.

.. details::
:title: Usage Details

qml.matrix can also be used with QNodes, tapes, or quantum functions that
contain multiple operations.

Consider the following quantum function:

.. code-block:: python3

def circuit(theta):
qml.RX(theta, wires=1)
qml.PauliZ(wires=0)

We can use qml.matrix to generate a new function that returns the unitary matrix
corresponding to the function circuit:

>>> matrix_fn = qml.matrix(circuit)
>>> theta = np.pi / 4
>>> matrix_fn(theta)
array([[ 0.92387953+0.j,  0.+0.j ,  0.-0.38268343j,  0.+0.j],
[ 0.+0.j,  -0.92387953+0.j,  0.+0.j,  0. +0.38268343j],
[ 0. -0.38268343j,  0.+0.j,  0.92387953+0.j,  0.+0.j],
[ 0.+0.j,  0.+0.38268343j,  0.+0.j,  -0.92387953+0.j]])

Note that since wire_order was not specified, the default order [1, 0] for circuit
was used, and the unitary matrix corresponds to the operation :math:Z\otimes R_X(\theta). To
obtain the matrix for :math:R_X(\theta)\otimes Z, specify wire_order=[0, 1] in the
function call:

>>> matrix = qml.matrix(circuit, wire_order=[0, 1])

You can also get the unitary matrix for operations on a subspace of a larger Hilbert space. For
example, with the same function circuit and wire_order=["a", 0, "b", 1] you obtain the
:math:16\times 16 matrix for the operation :math:I\otimes Z\otimes I\otimes  R_X(\theta).

This unitary matrix can also be used in differentiable calculations. For example, consider the
following cost function:

.. code-block:: python

def circuit(theta):
qml.RX(theta, wires=1) qml.PauliZ(wires=0)
qml.CNOT(wires=[0, 1])

def cost(theta):
matrix = qml.matrix(circuit)(theta)
return np.real(np.trace(matrix))

Since this cost function returns a real scalar as a function of theta, we can differentiate
it:

>>> cost(theta)
1.9775421558720845
-0.14943813247359922
"""
if isinstance(op, qml.operation.Tensor) and wire_order is not None:
op = 1.0 * op  # convert to a Hamiltonian

if isinstance(op, qml.Hamiltonian):
return qml.utils.sparse_hamiltonian(op, wires=wire_order).toarray()

return op.matrix(wire_order=wire_order)

@matrix.tape_transform
def _matrix(tape, wire_order=None):
"""Defines how matrix works if applied to a tape containing multiple operations."""
if not tape.wires:
raise qml.operation.MatrixUndefinedError
params = tape.get_parameters(trainable_only=False)
interface = qml.math.get_interface(*params)

wire_order = wire_order or tape.wires

# initialize the unitary matrix
if len(tape.operations) == 0:
result = qml.math.eye(2 ** len(wire_order), like=interface)
else:
result = matrix(tape.operations[0], wire_order=wire_order)

for op in tape.operations[1:]:
U = matrix(op, wire_order=wire_order)
# Coerce the matrices U and result and use matrix multiplication. Broadcasted axes
# are handled correctly automatically by matmul (See e.g. NumPy documentation)
result = qml.math.matmul(*qml.math.coerce([U, result], like=interface), like=interface)

return result


Using PennyLane

Development

API

Internals