def _decomposition_1_cnot(U, wires):
r"""If there is just one CNOT, we can write the circuit in the form
-╭U- = -C--╭C--A-
-╰U- = -D--╰X--B-
To do this decomposition, first we find G, H in SO(4) such that
G (Edag V E) H = (Edag U E)
where V depends on the central CNOT gate, and both U, V are in SU(4). This
is done following the methods in https://arxiv.org/pdf/quant-ph/0308045.pdf.
Once we find G and H, we can use the fact that E SO(4) Edag gives us
something in SU(2) x SU(2) to give A, B, C, D.
"""
# We will actually find a decomposition for the following circuit instead
# of the original U
# -╭U-╭SWAP- = -C--╭C-╭SWAP--B-
# -╰U-╰SWAP- = -D--╰X-╰SWAP--A-
# This ensures that the internal part of the decomposition has determinant 1.
swap_U = np.exp(1j * np.pi / 4) * math.dot(math.cast_like(SWAP, U), U)
# First let's compute gamma(u). For the one-CNOT case, uuT is always real.
u = math.dot(math.cast_like(Edag, U), math.dot(swap_U,
math.cast_like(E, U)))
uuT = math.dot(u, math.T(u))
# Since uuT is real, we can use eigh of its real part. eigh also orders the
# eigenvalues in ascending order.
_, p = math.linalg.eigh(qml.math.real(uuT))
# Fix the determinant if necessary so that p is in SO(4)
p = math.dot(p, math.diag([1, 1, 1, math.sign(math.linalg.det(p))]))
# Now, we must find q such that p uu^T p^T = q vv^T q^T.
# For this case, our V = SWAP CNOT01 is constant. Thus, we can compute v,
# vvT, and its eigenvalues and eigenvectors directly. These matrices are stored
# above as the constants v_one_cnot and q_one_cnot.
# Once we have p and q properly in SO(4), we compute G and H in SO(4) such
# that U = G V H
G = math.dot(p, q_one_cnot.T)
H = math.dot(math.conj(math.T(v_one_cnot)), math.dot(math.T(G), u))
# We now use the magic basis to convert G, H to SU(2) x SU(2)
AB = math.dot(E, math.dot(G, Edag))
CD = math.dot(E, math.dot(H, Edag))
# Extract the tensor prodcts to SU(2) x SU(2)
A, B = _su2su2_to_tensor_products(AB)
C, D = _su2su2_to_tensor_products(CD)
# Recover the operators in the decomposition; note that because of the
# initial SWAP, we exchange the order of A and B
A_ops = zyz_decomposition(A, wires[1])
B_ops = zyz_decomposition(B, wires[0])
C_ops = zyz_decomposition(C, wires[0])
D_ops = zyz_decomposition(D, wires[1])
return C_ops + D_ops + [qml.CNOT(wires=wires)] + A_ops + B_ops
def _su2su2_to_tensor_products(U):
r"""Given a matrix :math:`U = A \otimes B` in SU(2) x SU(2), extract the two SU(2)
operations A and B.
This process has been described in detail in the Appendix of Coffey & Deiotte
https://link.springer.com/article/10.1007/s11128-009-0156-3
"""
# First, write A = [[a1, a2], [-a2*, a1*]], which we can do for any SU(2) element.
# Then, A \otimes B = [[a1 B, a2 B], [-a2*B, a1*B]] = [[C1, C2], [C3, C4]]
# where the Ci are 2x2 matrices.
C1 = U[0:2, 0:2]
C2 = U[0:2, 2:4]
C3 = U[2:4, 0:2]
C4 = U[2:4, 2:4]
# From the definition of A \otimes B, C1 C4^\dag = a1^2 I, so we can extract a1
C14 = math.dot(C1, math.conj(math.T(C4)))
a1 = math.sqrt(math.cast_like(C14[0, 0], 1j))
# Similarly, -C2 C3^\dag = a2^2 I, so we can extract a2
C23 = math.dot(C2, math.conj(math.T(C3)))
a2 = math.sqrt(-math.cast_like(C23[0, 0], 1j))
# This gets us a1, a2 up to a sign. To resolve the sign, ensure that
# C1 C2^dag = a1 a2* I
C12 = math.dot(C1, math.conj(math.T(C2)))
if not math.allclose(a1 * math.conj(a2), C12[0, 0]):
a2 *= -1
# Construct A
A = math.stack(
[math.stack([a1, a2]),
math.stack([-math.conj(a2), math.conj(a1)])])
# Next, extract B. Can do from any of the C, just need to be careful in
# case one of the elements of A is 0.
if not math.allclose(A[0, 0], 0.0, atol=1e-6):
B = C1 / math.cast_like(A[0, 0], 1j)
else:
B = C2 / math.cast_like(A[0, 1], 1j)
return math.convert_like(A, U), math.convert_like(B, U)
def _yzy_to_zyz(middle_yzy):
"""Converts a set of angles representing a sequence of rotations RY, RZ, RY into
an equivalent sequence of the form RZ, RY, RZ.
Any rotation in 3-dimensional space (or, equivalently, any single-qubit unitary)
can be expressed as a sequence of rotations about 3 axes in 12 different ways.
Typically, the arbitrary single-qubit rotation is expressed as RZ(a) RY(b) RZ(c),
but there are some situations, e.g., composing two such rotations, where we need
to convert between representations. This function converts the angles of a sequence
.. math::
RY(y_1) RZ(z) RY(y_2)
into the form
.. math::
RZ(z_1) RY(y) RZ(z_2)
This is accomplished by first converting the rotation to quaternion form, and then
extracting the desired set of angles.
Args:
y1 (float): The angle of the first ``RY`` rotation.
z (float): The angle of the inner ``RZ`` rotation.
y2 (float): The angle of the second ``RY`` rotation.
Returns:
tuple[float, float, float]: A list of rotation angles in the ZYZ representation.
"""
if allclose(stack(middle_yzy), cast_like(zeros(3), stack(middle_yzy))):
return stack([0.0, 0.0, 0.0])
y1, z, y2 = middle_yzy[0], middle_yzy[1], middle_yzy[2]
# First, compute the quaternion representation
# https://ntrs.nasa.gov/api/citations/19770024290/downloads/19770024290.pdf
qw = cos(z / 2) * cos(0.5 * (y1 + y2))
qx = sin(z / 2) * sin(0.5 * (y1 - y2))
qy = cos(z / 2) * sin(0.5 * (y1 + y2))
qz = sin(z / 2) * cos(0.5 * (y1 - y2))
# Now convert from YZY Euler angles to ZYZ angles
# Source: http://bediyap.com/programming/convert-quaternion-to-euler-rotations/
z1_arg1 = 2 * (qy * qz - qw * qx)
z1_arg2 = 2 * (qx * qz + qw * qy)
z1 = arctan2(z1_arg1, z1_arg2)
y = arccos(qw ** 2 - qx ** 2 - qy ** 2 + qz ** 2)
z2_arg1 = 2 * (qy * qz + qw * qx)
z2_arg2 = -2 * (qx * qz - qw * qy)
z2 = arctan2(z2_arg1, z2_arg2)
return stack([z1, y, z2])
def test_cast_like(t1, t2):
"""Test that casting t1 like t2 results in t1 being cast to the same datatype as t2"""
res = fn.cast_like(t1, t2)
# if tensorflow or pytorch, extract view of underlying data
if hasattr(res, "numpy"):
res = res.numpy()
if hasattr(t2, "numpy"):
t2 = t2.numpy()
assert fn.allequal(res, t1)
assert onp.asarray(res).dtype.type is onp.asarray(t2).dtype.type
def _convert_to_su4(U):
r"""Check unitarity of a 4x4 matrix and convert it to :math:`SU(4)` if the determinant is not 1.
Args:
U (array[complex]): A matrix, presumed to be :math:`4 \times 4` and unitary.
Returns:
array[complex]: A :math:`4 \times 4` matrix in :math:`SU(4)` that is
equivalent to U up to a global phase.
"""
# Check unitarity
if not math.allclose(
math.dot(U, math.T(math.conj(U))), math.eye(4), atol=1e-7):
raise ValueError("Operator must be unitary.")
# Compute the determinant
det = math.linalg.det(U)
# Convert to SU(4) if it's not close to 1
if not math.allclose(det, 1.0):
exp_angle = -1j * math.cast_like(math.angle(det), 1j) / 4
U = math.cast_like(U, det) * math.exp(exp_angle)
return U
def _convert_to_su2(U):
r"""Check unitarity of a matrix and convert it to :math:`SU(2)` if possible.
Args:
U (array[complex]): A matrix, presumed to be :math:`2 \times 2` and unitary.
Returns:
array[complex]: A :math:`2 \times 2` matrix in :math:`SU(2)` that is
equivalent to U up to a global phase.
"""
# Check unitarity
if not math.allclose(
math.dot(U, math.T(math.conj(U))), math.eye(2), atol=1e-7):
raise ValueError("Operator must be unitary.")
# Compute the determinant
det = U[0, 0] * U[1, 1] - U[0, 1] * U[1, 0]
# Convert to SU(2) if it's not close to 1
if not math.allclose(det, [1.0]):
exp_angle = -1j * math.cast_like(math.angle(det), 1j) / 2
U = math.cast_like(U, exp_angle) * math.exp(exp_angle)
return U
def _decomposition_3_cnots(U, wires):
r"""The most general form of this decomposition is U = (A \otimes B) V (C \otimes D),
where V is as depicted in the circuit below:
-╭U- = -C--╭X--RZ(d)--╭C---------╭X--A-
-╰U- = -D--╰C--RY(b)--╰X--RY(a)--╰C--B-
"""
# First we add a SWAP as per v1 of arXiv:0308033, which helps with some
# rearranging of gates in the decomposition (it will cancel out the fact
# that we need to add a SWAP to fix the determinant in another part later).
swap_U = np.exp(1j * np.pi / 4) * math.dot(math.cast_like(SWAP, U), U)
# Choose the rotation angles of RZ, RY in the two-qubit decomposition.
# They are chosen as per Proposition V.1 in quant-ph/0308033 and are based
# on the phases of the eigenvalues of :math:`E^\dagger \gamma(U) E`, where
# \gamma(U) = (E^\dag U E) (E^\dag U E)^T.
# The rotation angles can be computed as follows (any three eigenvalues can be used)
u = math.dot(Edag, math.dot(swap_U, E))
gammaU = math.dot(u, math.T(u))
evs, _ = math.linalg.eig(gammaU)
# We will sort the angles so that results are consistent across interfaces.
angles = math.sort([math.angle(ev) for ev in evs])
x, y, z = angles[0], angles[1], angles[2]
# Compute functions of the eigenvalues; there are different options in v1
# vs. v3 of the paper, I'm not entirely sure why. This is the version from v3.
alpha = (x + y) / 2
beta = (x + z) / 2
delta = (z + y) / 2
# This is the interior portion of the decomposition circuit
interior_decomp = [
qml.CNOT(wires=[wires[1], wires[0]]),
qml.RZ(delta, wires=wires[0]),
qml.RY(beta, wires=wires[1]),
qml.CNOT(wires=wires),
qml.RY(alpha, wires=wires[1]),
qml.CNOT(wires=[wires[1], wires[0]]),
]
# We need the matrix representation of this interior part, V, in order to
# decompose U = (A \otimes B) V (C \otimes D)
#
# Looking at the decomposition above, V has determinant -1 (because there
# are 3 CNOTs, each with determinant -1). The relationship between U and V
# requires that both are in SU(4), so we add a SWAP after to V. We will see
# how this gets fixed later.
#
# -╭V- = -╭X--RZ(d)--╭C---------╭X--╭SWAP-
# -╰V- = -╰C--RY(b)--╰X--RY(a)--╰C--╰SWAP-
RZd = qml.RZ(math.cast_like(delta, 1j), wires=wires[0]).matrix
RYb = qml.RY(beta, wires=wires[0]).matrix
RYa = qml.RY(alpha, wires=wires[0]).matrix
V_mats = [
CNOT10,
math.kron(RZd, RYb), CNOT01,
math.kron(math.eye(2), RYa), CNOT10, SWAP
]
V = math.convert_like(math.eye(4), U)
for mat in V_mats:
V = math.dot(math.cast_like(mat, U), V)
# Now we need to find the four SU(2) operations A, B, C, D
A, B, C, D = _extract_su2su2_prefactors(swap_U, V)
# At this point, we have the following:
# -╭U-╭SWAP- = --C--╭X-RZ(d)-╭C-------╭X-╭SWAP--A
# -╰U-╰SWAP- = --D--╰C-RZ(b)-╰X-RY(a)-╰C-╰SWAP--B
#
# Using the relationship that SWAP(A \otimes B) SWAP = B \otimes A,
# -╭U-╭SWAP- = --C--╭X-RZ(d)-╭C-------╭X--B--╭SWAP-
# -╰U-╰SWAP- = --D--╰C-RZ(b)-╰X-RY(a)-╰C--A--╰SWAP-
#
# Now the SWAPs cancel, giving us the desired decomposition
# (up to a global phase).
# -╭U- = --C--╭X-RZ(d)-╭C-------╭X--B--
# -╰U- = --D--╰C-RZ(b)-╰X-RY(a)-╰C--A--
A_ops = zyz_decomposition(A, wires[1])
B_ops = zyz_decomposition(B, wires[0])
C_ops = zyz_decomposition(C, wires[0])
D_ops = zyz_decomposition(D, wires[1])
# Return the full decomposition
return C_ops + D_ops + interior_decomp + A_ops + B_ops
def _decomposition_2_cnots(U, wires):
r"""If 2 CNOTs are required, we can write the circuit as
-╭U- = -A--╭X--RZ(d)--╭X--C-
-╰U- = -B--╰C--RX(p)--╰C--D-
We need to find the angles for the Z and X rotations such that the inner
part has the same spectrum as U, and then we can recover A, B, C, D.
"""
# Compute the rotation angles
u = math.dot(Edag, math.dot(U, E))
gammaU = math.dot(u, math.T(u))
evs, _ = math.linalg.eig(gammaU)
# These choices are based on Proposition III.3 of
# https://arxiv.org/abs/quant-ph/0308045
# There is, however, a special case where the circuit has the form
# -╭U- = -A--╭C--╭X--C-
# -╰U- = -B--╰X--╰C--D-
#
# or some variant of this, where the two CNOTs are adjacent.
#
# What happens here is that the set of evs is -1, -1, 1, 1 and we can write
# -╭U- = -A--╭X--SZ--╭X--C-
# -╰U- = -B--╰C--SX--╰C--D-
# where SZ and SX are square roots of Z and X respectively. (This
# decomposition comes from using Hadamards to flip the direction of the
# first CNOT, and then decomposing them and merging single-qubit gates.) For
# some reason this case is not handled properly with the full algorithm, so
# we treat it separately.
sorted_evs = math.sort(math.real(evs))
if math.allclose(sorted_evs, [-1, -1, 1, 1]):
interior_decomp = [
qml.CNOT(wires=[wires[1], wires[0]]),
qml.S(wires=wires[0]),
qml.SX(wires=wires[1]),
qml.CNOT(wires=[wires[1], wires[0]]),
]
# S \otimes SX
inner_matrix = S_SX
else:
# For the non-special case, the eigenvalues come in conjugate pairs.
# We need to find two non-conjugate eigenvalues to extract the angles.
x = math.angle(evs[0])
y = math.angle(evs[1])
# If it was the conjugate, grab a different eigenvalue.
if math.allclose(x, -y):
y = math.angle(evs[2])
delta = (x + y) / 2
phi = (x - y) / 2
interior_decomp = [
qml.CNOT(wires=[wires[1], wires[0]]),
qml.RZ(delta, wires=wires[0]),
qml.RX(phi, wires=wires[1]),
qml.CNOT(wires=[wires[1], wires[0]]),
]
RZd = qml.RZ(math.cast_like(delta, 1j), wires=0).matrix
RXp = qml.RX(phi, wires=0).matrix
inner_matrix = math.kron(RZd, RXp)
# We need the matrix representation of this interior part, V, in order to
# decompose U = (A \otimes B) V (C \otimes D)
V = math.dot(math.cast_like(CNOT10, U),
math.dot(inner_matrix, math.cast_like(CNOT10, U)))
# Now we find the A, B, C, D in SU(2), and return the decomposition
A, B, C, D = _extract_su2su2_prefactors(U, V)
A_ops = zyz_decomposition(A, wires[0])
B_ops = zyz_decomposition(B, wires[1])
C_ops = zyz_decomposition(C, wires[0])
D_ops = zyz_decomposition(D, wires[1])
return C_ops + D_ops + interior_decomp + A_ops + B_ops
def _extract_su2su2_prefactors(U, V):
r"""This function is used for the case of 2 CNOTs and 3 CNOTs. It does something
similar as the 1-CNOT case, but there is no special form for one of the
SO(4) operations.
Suppose U, V are SU(4) matrices for which there exists A, B, C, D such that
(A \otimes B) V (C \otimes D) = U. The problem is to find A, B, C, D in SU(2)
in an analytic and fully differentiable manner.
This decomposition is possible when U and V are in the same double coset of
SU(4), meaning there exists G, H in SO(4) s.t. G (Edag V E) H = (Edag U
E). This is guaranteed here by how V was constructed in both the
_decomposition_2_cnots and _decomposition_3_cnots methods.
Then, we can use the fact that E SO(4) Edag gives us something in SU(2) x
SU(2) to give A, B, C, D.
"""
# A lot of the work here happens in the magic basis. Essentially, we
# don't look explicitly at some U = G V H, but rather at
# E^\dagger U E = G E^\dagger V E H
# so that we can recover
# U = (E G E^\dagger) V (E H E^\dagger) = (A \otimes B) V (C \otimes D).
# There is some math in the paper explaining how when we define U in this way,
# we can simultaneously diagonalize functions of U and V to ensure they are
# in the same coset and recover the decomposition.
u = math.dot(math.cast_like(Edag, V), math.dot(U, math.cast_like(E, V)))
v = math.dot(math.cast_like(Edag, V), math.dot(V, math.cast_like(E, V)))
uuT = math.dot(u, math.T(u))
vvT = math.dot(v, math.T(v))
# Get the p and q in SO(4) that diagonalize uuT and vvT respectively (and
# their eigenvalues). We are looking for a simultaneous diagonalization,
# which we know exists because of how U and V were constructed. Furthermore,
# The way we will do this is by noting that, since uuT/vvT are complex and
# symmetric, so both their real and imaginary parts share a set of
# real-valued eigenvectors, which are also eigenvectors of uuT/vvT
# themselves. So we can use eigh, which orders the eigenvectors, and so we
# are guaranteed that the p and q returned will be "in the same order".
_, p = math.linalg.eigh(math.real(uuT) + math.imag(uuT))
_, q = math.linalg.eigh(math.real(vvT) + math.imag(vvT))
# If determinant of p/q is not 1, it is in O(4) but not SO(4), and has determinant
# We can transform it to SO(4) by simply negating one of the columns.
p = math.dot(p, math.diag([1, 1, 1, math.sign(math.linalg.det(p))]))
q = math.dot(q, math.diag([1, 1, 1, math.sign(math.linalg.det(q))]))
# Now, we should have p, q in SO(4) such that p^T u u^T p = q^T v v^T q.
# Then (v^\dag q p^T u)(v^\dag q p^T u)^T = I.
# So we can set G = p q^T, H = v^\dag q p^T u to obtain G v H = u.
G = math.dot(math.cast_like(p, 1j), math.T(q))
H = math.dot(math.conj(math.T(v)), math.dot(math.T(G), u))
# These are still in SO(4) though - we want to convert things into SU(2) x SU(2)
# so use the entangler. Since u = E^\dagger U E and v = E^\dagger V E where U, V
# are the target matrices, we can reshuffle as in the docstring above,
# U = (E G E^\dagger) V (E H E^\dagger) = (A \otimes B) V (C \otimes D)
# where A, B, C, D are in SU(2) x SU(2).
AB = math.dot(math.cast_like(E, G), math.dot(G, math.cast_like(Edag, G)))
CD = math.dot(math.cast_like(E, H), math.dot(H, math.cast_like(Edag, H)))
# Now, we just need to extract the constituent tensor products.
A, B = _su2su2_to_tensor_products(AB)
C, D = _su2su2_to_tensor_products(CD)
return A, B, C, D
def zyz_decomposition(U, wire):
r"""Recover the decomposition of a single-qubit matrix :math:`U` in terms of
elementary operations.
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 in the form :math:`RZ(\omega) RY(\theta) RZ(\phi)`.
Args:
U (tensor): A 2 x 2 unitary matrix.
wire (Union[Wires, Sequence[int] or int]): The wire on which to apply the operation.
Returns:
list[qml.Operation]: A ``Rot`` gate on the specified wire that implements ``U``
up to a global phase, or an equivalent ``RZ`` gate if ``U`` is diagonal.
**Example**
Suppose we would like to apply the following unitary operation:
.. code-block:: python3
U = np.array([
[-0.28829348-0.78829734j, 0.30364367+0.45085995j],
[ 0.53396245-0.10177564j, 0.76279558-0.35024096j]
])
For PennyLane devices that cannot natively implement ``QubitUnitary``, we
can instead recover a ``Rot`` gate that implements the same operation, up
to a global phase:
>>> decomp = zyz_decomposition(U, 0)
>>> decomp
[Rot(-0.24209529417800013, 1.14938178234275, 1.7330581433950871, wires=[0])]
"""
U = _convert_to_su2(U)
# Check if the matrix is diagonal; only need to check one corner.
# If it is diagonal, we don't need a full Rot, just return an RZ.
if math.allclose(U[0, 1], [0.0]):
omega = 2 * math.angle(U[1, 1])
return [qml.RZ(omega, wires=wire)]
# If the top left element is 0, can only use the off-diagonal elements. We
# have to be very careful with the math here to ensure things that get
# multiplied together are of the correct type in the different interfaces.
if math.allclose(U[0, 0], [0.0]):
phi = 0.0
theta = -np.pi
omega = 1j * math.log(U[0, 1] / U[1, 0]) - np.pi
else:
# If not diagonal, compute the angle of the RY
cos2_theta_over_2 = math.abs(U[0, 0] * U[1, 1])
theta = 2 * math.arccos(math.sqrt(cos2_theta_over_2))
el_division = U[0, 0] / U[1, 0]
tan_part = math.cast_like(math.tan(theta / 2), el_division)
omega = 1j * math.log(tan_part * el_division)
phi = -omega - math.cast_like(2 * math.angle(U[0, 0]), omega)
return [
qml.Rot(math.real(phi), math.real(theta), math.real(omega), wires=wire)
]
def merge_rotations(tape, atol=1e-8, include_gates=None):
r"""Quantum function transform to combine rotation gates of the same type
that act sequentially.
If the combination of two rotation produces an angle that is close to 0,
neither gate will be applied.
Args:
qfunc (function): A quantum function.
atol (float): After fusion of gates, if the fused angle :math:`\theta` is such that
:math:`|\theta|\leq \text{atol}`, no rotation gate will be applied.
include_gates (None or list[str]): A list of specific operations to merge. If
set to ``None`` (default), all operations with the ``is_composable_rotation``
attribute set to ``True`` will be merged. Otherwise, only the operations whose
names match those in the list will undergo merging.
**Example**
Consider the following quantum function.
.. code-block:: python
def qfunc(x, y, z):
qml.RX(x, wires=0)
qml.RX(y, wires=0)
qml.CNOT(wires=[1, 2])
qml.RY(y, wires=1)
qml.Hadamard(wires=2)
qml.CRZ(z, wires=[2, 0])
qml.RY(-y, wires=1)
return qml.expval(qml.PauliZ(0))
The circuit before optimization:
>>> dev = qml.device('default.qubit', wires=3)
>>> qnode = qml.QNode(qfunc, dev)
>>> print(qml.draw(qnode)(1, 2, 3))
0: ───RX(1)──RX(2)──────────╭RZ(3)──┤ ⟨Z⟩
1: ──╭C──────RY(2)──RY(-2)──│───────┤
2: ──╰X──────H──────────────╰C──────┤
By inspection, we can combine the two ``RX`` rotations on the first qubit.
On the second qubit, we have a cumulative angle of 0, and the gates will cancel.
>>> optimized_qfunc = merge_rotations()(qfunc)
>>> optimized_qnode = qml.QNode(optimized_qfunc, dev)
>>> print(qml.draw(optimized_qnode)(1, 2, 3))
0: ───RX(3)─────╭RZ(3)──┤ ⟨Z⟩
1: ──╭C─────────│───────┤
2: ──╰X──────H──╰C──────┤
It is also possible to explicitly specify which rotations ``merge_rotations`` should
be merged using the ``include_gates`` argument. For example, if in the above
circuit we wanted only to merge the "RX" gates, we could do so as follows:
>>> optimized_qfunc = merge_rotations(include_gates=["RX"])(qfunc)
>>> optimized_qnode = qml.QNode(optimized_qfunc, dev)
>>> print(qml.draw(optimized_qnode)(1, 2, 3))
0: ───RX(3)─────────────────╭RZ(3)──┤ ⟨Z⟩
1: ──╭C──────RY(2)──RY(-2)──│───────┤
2: ──╰X──────H──────────────╰C──────┤
"""
# Make a working copy of the list to traverse
list_copy = tape.operations.copy()
while len(list_copy) > 0:
current_gate = list_copy[0]
# If a specific list of operations is specified, check and see if our
# op is in it, then try to merge. If not, queue and move on.
if include_gates is not None:
if current_gate.name not in include_gates:
apply(current_gate)
list_copy.pop(0)
continue
# Check if the rotation is composable; if it is not, move on.
if not current_gate.is_composable_rotation:
apply(current_gate)
list_copy.pop(0)
continue
# Find the next gate that acts on the same wires
next_gate_idx = find_next_gate(current_gate.wires, list_copy[1:])
# If no such gate is found (either there simply is none, or there are other gates
# "in the way", queue the operation and move on
if next_gate_idx is None:
apply(current_gate)
list_copy.pop(0)
continue
# We need to use stack to get this to work and be differentiable in all interfaces
cumulative_angles = stack(current_gate.parameters)
# As long as there is a valid next gate, check if we can merge the angles
while next_gate_idx is not None:
# Get the next gate
next_gate = list_copy[next_gate_idx + 1]
# If next gate is of the same type, we can merge the angles
if current_gate.name == next_gate.name and current_gate.wires == next_gate.wires:
list_copy.pop(next_gate_idx + 1)
# The Rot gate must be treated separately
if current_gate.name == "Rot":
cumulative_angles = fuse_rot_angles(
cumulative_angles,
cast_like(stack(next_gate.parameters),
cumulative_angles))
# Other, single-parameter rotation gates just have the angle summed
else:
cumulative_angles = cumulative_angles + cast_like(
stack(next_gate.parameters), cumulative_angles)
# If it is not, we need to stop
else:
break
# If we did merge, look now at the next gate
next_gate_idx = find_next_gate(current_gate.wires, list_copy[1:])
if not allclose(cumulative_angles,
zeros(len(cumulative_angles)),
atol=atol,
rtol=0):
current_gate.__class__(*cumulative_angles,
wires=current_gate.wires)
# Remove the first gate gate from the working list
list_copy.pop(0)
# Queue the measurements normally
for m in tape.measurements:
apply(m)
def single_qubit_fusion(tape, atol=1e-8, exclude_gates=None):
r"""Quantum function transform to fuse together groups of single-qubit
operations into a general single-qubit unitary operation (:class:`~.Rot`).
Fusion is performed only between gates that implement the property
``single_qubit_rot_angles``. Any sequence of two or more single-qubit gates
(on the same qubit) with that property defined will be fused into one ``Rot``.
Args:
qfunc (function): A quantum function.
atol (float): An absolute tolerance for which to apply a rotation after
fusion. After fusion of gates, if the fused angles :math:`\theta` are such that
:math:`|\theta|\leq \text{atol}`, no rotation gate will be applied.
exclude_gates (None or list[str]): A list of gates that should be excluded
from full fusion. If set to ``None``, all single-qubit gates that can
be fused will be fused.
Returns:
function: the transformed quantum function
**Example**
Consider the following quantum function.
.. code-block:: python
def qfunc(r1, r2):
qml.Hadamard(wires=0)
qml.Rot(*r1, wires=0)
qml.Rot(*r2, wires=0)
qml.RZ(r1[0], wires=0)
qml.RZ(r2[0], wires=0)
return qml.expval(qml.PauliX(0))
The circuit before optimization:
>>> dev = qml.device('default.qubit', wires=1)
>>> qnode = qml.QNode(qfunc, dev)
>>> print(qml.draw(qnode)([0.1, 0.2, 0.3], [0.4, 0.5, 0.6]))
0: ──H──Rot(0.1, 0.2, 0.3)──Rot(0.4, 0.5, 0.6)──RZ(0.1)──RZ(0.4)──┤ ⟨X⟩
Full single-qubit gate fusion allows us to collapse this entire sequence into a
single ``qml.Rot`` rotation gate.
>>> optimized_qfunc = single_qubit_fusion()(qfunc)
>>> optimized_qnode = qml.QNode(optimized_qfunc, dev)
>>> print(qml.draw(optimized_qnode)([0.1, 0.2, 0.3], [0.4, 0.5, 0.6]))
0: ──Rot(3.57, 2.09, 2.05)──┤ ⟨X⟩
"""
# Make a working copy of the list to traverse
list_copy = tape.operations.copy()
while len(list_copy) > 0:
current_gate = list_copy[0]
# If the gate should be excluded, queue it and move on regardless
# of fusion potential
if exclude_gates is not None:
if current_gate.name in exclude_gates:
apply(current_gate)
list_copy.pop(0)
continue
# Look for single_qubit_rot_angles; if not available, queue and move on.
# If available, grab the angles and try to fuse.
try:
cumulative_angles = stack(current_gate.single_qubit_rot_angles())
except (NotImplementedError, AttributeError):
apply(current_gate)
list_copy.pop(0)
continue
# Find the next gate that acts on the same wires
next_gate_idx = find_next_gate(current_gate.wires, list_copy[1:])
if next_gate_idx is None:
apply(current_gate)
list_copy.pop(0)
continue
# Before entering the loop, we check to make sure the next gate is not in the
# exclusion list. If it is, we should apply the original gate as-is, and not the
# Rot version (example in test test_single_qubit_fusion_exclude_gates).
if exclude_gates is not None:
next_gate = list_copy[next_gate_idx + 1]
if next_gate.name in exclude_gates:
apply(current_gate)
list_copy.pop(0)
continue
# Loop as long as a valid next gate exists
while next_gate_idx is not None:
next_gate = list_copy[next_gate_idx + 1]
# Check first if the next gate is in the exclusion list
if exclude_gates is not None:
if next_gate.name in exclude_gates:
break
# Try to extract the angles; since the Rot angles are implemented
# solely for single-qubit gates, and we used find_next_gate to obtain
# the gate in question, only valid single-qubit gates on the same
# wire as the current gate will be fused.
try:
next_gate_angles = next_gate.single_qubit_rot_angles()
except (NotImplementedError, AttributeError):
break
cumulative_angles = fuse_rot_angles(
cumulative_angles,
cast_like(stack(next_gate_angles), cumulative_angles))
list_copy.pop(next_gate_idx + 1)
next_gate_idx = find_next_gate(current_gate.wires, list_copy[1:])
# Only apply if the cumulative angle is not close to 0
if not allclose(cumulative_angles, zeros(3), atol=atol, rtol=0):
Rot(*cumulative_angles, wires=current_gate.wires)
# Remove the starting gate from the list
list_copy.pop(0)
# Queue the measurements normally
for m in tape.measurements:
apply(m)
