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 test_angle(t):
"""Test that the angle function works for a variety
of input"""
res = fn.angle(t)
assert fn.allequal(res, [0, np.pi / 2, np.pi / 4])
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)
]