def fuse_rot_angles(angles_1, angles_2):
"""Computed the set of rotation angles that is obtained when composing
two ``qml.Rot`` operations.
The ``qml.Rot`` operation represents the most general single-qubit operation.
Two such operations can be fused into a new operation, however the angular dependence
is non-trivial.
Args:
angles_1 (float): A set of three angles for the first ``qml.Rot`` operation.
angles_2 (float): A set of three angles for the second ``qml.Rot`` operation.
Returns:
array[float]: A tuple of rotation angles for a single ``qml.Rot`` operation
that implements the same operation as the two sets of input angles.
"""
# Check for all-zero instances; if there are some, we can just return the sum.
are_angles_1_zero = allclose(angles_1, zeros(3))
are_angles_2_zero = allclose(angles_2, zeros(3))
if are_angles_1_zero or are_angles_2_zero:
return stack([angles_1[i] + angles_2[i] for i in range(3)])
# RZ(a) RY(b) RZ(c) fused with RZ(d) RY(e) RZ(f)
# first produces RZ(a) RY(b) RZ(c+d) RY(e) RZ(f)
left_z = angles_1[0]
middle_yzy = angles_1[1], angles_1[2] + angles_2[0], angles_2[1]
right_z = angles_2[2]
# There are a few other cases to consider where things can be 0 and
# avoid having to use the quaternion conversion routine
# If b = 0, then we have RZ(a + c + d) RY(e) RZ(f)
if allclose(middle_yzy[0], 0.0):
# Then if e is close to zero, return a single rotation RZ(a + c + d + f)
if allclose(middle_yzy[2], 0.0):
return [left_z + middle_yzy[1] + right_z, 0.0, 0.0]
return stack([left_z + middle_yzy[1], middle_yzy[2], right_z])
# If c + d is close to 0, then we have the case RZ(a) RY(b + e) RZ(f)
if allclose(middle_yzy[1], 0.0):
# If b + e is 0, we have RZ(a + f)
if allclose(middle_yzy[0] + middle_yzy[2], 0.0):
return [left_z + right_z, 0.0, 0.0]
return stack([left_z, middle_yzy[0] + middle_yzy[2], right_z])
# If e is close to 0, then we have the case RZ(a) RY(b) RZ(c + d + f)
# The case where b is 0 actually already covered in the first loop,
# so only one case here.
if allclose(middle_yzy[2], 0.0):
return stack([left_z, middle_yzy[0], middle_yzy[1] + right_z])
# Otherwise, we need to turn the RY(b) RZ(c+d) RY(e) into something
# of the form RZ(u) RY(v) RZ(w)
u, v, w = _yzy_to_zyz(middle_yzy)
# Then we can combine to create
# RZ(a + u) RY(v) RZ(w + f)
return stack([left_z + u, v, w + right_z])
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_stack_array_jax(self):
"""Test that stack, called without the axis arguments, stacks vertically"""
t1 = onp.array([0.6, 0.1, 0.6])
t2 = jnp.array([0.1, 0.2, 0.3])
t3 = jnp.array([5.0, 8.0, 101.0])
res = fn.stack([t1, t2, t3])
assert np.all(res == np.stack([t1, t2, t3]))
def test_stack_torch(self):
"""Test that stack, called without the axis arguments, stacks vertically"""
t1 = onp.array([5.0, 8.0, 101.0], dtype=np.float64)
t2 = torch.tensor([0.6, 0.1, 0.6], dtype=torch.float64)
t3 = torch.tensor([0.1, 0.2, 0.3], dtype=torch.float64)
res = fn.stack([t1, t2, t3])
assert isinstance(res, torch.Tensor)
assert np.all(res.numpy() == np.stack([t1, t2.numpy(), t3.numpy()]))
def test_stack_tensorflow(self):
"""Test that stack, called without the axis arguments, stacks vertically"""
t1 = tf.constant([0.6, 0.1, 0.6])
t2 = tf.Variable([0.1, 0.2, 0.3])
t3 = onp.array([5.0, 8.0, 101.0])
res = fn.stack([t1, t2, t3])
assert isinstance(res, tf.Tensor)
assert np.all(res.numpy() == np.stack([t1.numpy(), t2.numpy(), t3]))
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 test_stack_axis(self, t1):
"""Test that passing the axis argument allows for stacking along
a different axis"""
t2 = onp.array([3, 4])
res = fn.stack([t1, t2], axis=1)
# if tensorflow or pytorch, extract view of underlying data
if hasattr(res, "numpy"):
res = res.numpy()
assert fn.allclose(res, np.array([[1, 3], [2, 4]]))
assert list(res.shape) == [2, 2]
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)