def test_two_qubit_decomposition_tf(self, U, wires):
"""Test that a two-qubit operation in Tensorflow is correctly decomposed."""
tf = pytest.importorskip("tensorflow")
U = tf.Variable(U, dtype=tf.complex128)
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def test_two_qubit_decomposition_1_cnot(self, U, wires):
"""Test that a two-qubit matrix using one CNOT is correctly decomposed."""
U = _convert_to_su4(np.array(U))
assert _compute_num_cnots(U) == 1
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
assert len(obtained_decomposition) == 5
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def test_two_qubit_decomposition_tensor_products(self, U_pair, wires):
"""Test that a two-qubit tensor product matrix is correctly decomposed."""
U = _convert_to_su4(
qml.math.kron(np.array(U_pair[0]), np.array(U_pair[1])))
assert _compute_num_cnots(U) == 0
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
assert len(obtained_decomposition) == 2
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def test_two_qubit_decomposition_tensor_products_torch(
self, U_pair, wires):
"""Test that a two-qubit tensor product in Torch is correctly decomposed."""
torch = pytest.importorskip("torch")
U1 = torch.tensor(U_pair[0], dtype=torch.complex128)
U2 = torch.tensor(U_pair[1], dtype=torch.complex128)
U = qml.math.kron(U1, U2)
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def test_two_qubit_decomposition_3_cnots(self, U, wires):
"""Test that a two-qubit matrix using 3 CNOTs is correctly decomposed."""
U = _convert_to_su4(np.array(U))
assert _compute_num_cnots(U) == 3
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
assert len(obtained_decomposition) == 10
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
# We check with a slightly great tolerance threshold here simply because the
# test matrices were copied in here with reduced precision.
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def test_two_qubit_decomposition_jax(self, U, wires):
"""Test that a two-qubit operation in JAX is correctly decomposed."""
jax = pytest.importorskip("jax")
from jax.config import config
remember = config.read("jax_enable_x64")
config.update("jax_enable_x64", True)
U = jax.numpy.array(U, dtype=jax.numpy.complex128)
obtained_decomposition = two_qubit_decomposition(U, wires=wires)
with qml.tape.QuantumTape() as tape:
for op in obtained_decomposition:
qml.apply(op)
obtained_matrix = get_unitary_matrix(tape, wire_order=wires)()
assert check_matrix_equivalence(U, obtained_matrix, atol=1e-7)
def unitary_to_rot(tape):
r"""Quantum function transform to decomposes all instances of single-qubit and
select instances of two-qubit :class:`~.QubitUnitary` operations to
parametrized single-qubit operations.
For single-qubit gates, diagonal operations will be converted to a single
:class:`.RZ` gate, while non-diagonal operations will be converted to a
:class:`.Rot` gate that implements the original operation up to a global
phase. Two-qubit gates will be decomposed according to the
:func:`pennylane.transforms.two_qubit_decomposition` function.
.. warning::
This transform is not fully differentiable for 2-qubit ``QubitUnitary``
operations. See usage details below.
Args:
qfunc (function): a quantum function
**Example**
Suppose we would like to apply the following unitary operation:
.. code-block:: python3
U = np.array([
[-0.17111489+0.58564875j, -0.69352236-0.38309524j],
[ 0.25053735+0.75164238j, 0.60700543-0.06171855j]
])
The ``unitary_to_rot`` transform enables us to decompose such numerical
operations while preserving differentiability.
.. code-block:: python3
def qfunc():
qml.QubitUnitary(U, wires=0)
return qml.expval(qml.PauliZ(0))
The original circuit is:
>>> dev = qml.device('default.qubit', wires=1)
>>> qnode = qml.QNode(qfunc, dev)
>>> print(qml.draw(qnode)())
0: ──U0──┤ ⟨Z⟩
U0 =
[[-0.17111489+0.58564875j -0.69352236-0.38309524j]
[ 0.25053735+0.75164238j 0.60700543-0.06171855j]]
We can use the transform to decompose the gate:
>>> transformed_qfunc = unitary_to_rot(qfunc)
>>> transformed_qnode = qml.QNode(transformed_qfunc, dev)
>>> print(qml.draw(transformed_qnode)())
0: ──Rot(-1.35, 1.83, -0.606)──┤ ⟨Z⟩
.. UsageDetails::
This decomposition is not fully differentiable. We **can** differentiate
with respect to input QNode parameters when they are not used to
explicitly construct a :math:`4 \times 4` unitary matrix being
decomposed. So for example, the following will work:
.. code-block:: python3
U = scipy.stats.unitary_group.rvs(4)
def circuit(angles):
qml.QubitUnitary(U, wires=["a", "b"])
qml.RX(angles[0], wires="a")
qml.RY(angles[1], wires="b")
qml.CNOT(wires=["b", "a"])
return qml.expval(qml.PauliZ(wires="a"))
dev = qml.device('default.qubit', wires=["a", "b"])
transformed_qfunc = qml.transforms.unitary_to_rot(circuit)
transformed_qnode = qml.QNode(transformed_qfunc, dev)
>>> g = qml.grad(transformed_qnode)
>>> params = np.array([0.2, 0.3], requires_grad=True)
>>> g(params)
array([ 0.00296633, -0.29392145])
However, the following example will **not** be differentiable:
.. code-block:: python3
def circuit(angles):
z = angles[0]
x = angles[1]
Z_mat = np.array([[np.exp(-1j * z / 2), 0.0], [0.0, np.exp(1j * z / 2)]])
c = np.cos(x / 2)
s = np.sin(x / 2) * 1j
X_mat = np.array([[c, -s], [-s, c]])
U = np.kron(Z_mat, X_mat)
qml.Hadamard(wires="a")
# U depends on the input parameters
qml.QubitUnitary(U, wires=["a", "b"])
qml.CNOT(wires=["b", "a"])
return qml.expval(qml.PauliX(wires="a"))
"""
for op in tape.operations + tape.measurements:
if isinstance(op, qml.QubitUnitary):
# Single-qubit unitary operations
if qml.math.shape(op.parameters[0]) == (2, 2):
zyz_decomposition(op.parameters[0], op.wires[0])
# Two-qubit unitary operations
elif qml.math.shape(op.parameters[0]) == (4, 4):
two_qubit_decomposition(op.parameters[0], op.wires)
else:
qml.apply(op)
else:
qml.apply(op)
