[skip-ci]

[skip-ci]

Co-authored-by: David Wierichs <david.wierichs@xanadu.ai>

doc/releases/changelog-dev.md

@@ -104,8 +104,8 @@
 * Two new functions called :func:`~.math.convert_to_su2` and :func:`~.math.convert_to_su4` have been added to `qml.math`, which convert unitary matrices to SU(2) or SU(4), respectively, and optionally a global phase.
   [(#7211)](https://github.com/PennyLaneAI/pennylane/pull/7211)
 
-* A new template :class:`~.Elbow` has been added. The Elbow operator is a three-qubit gate analogous to an AND or Toffoli gate that leverages extra information
-  in the target wire to enable more efficient a decomposition. It is useful in context such as efficient decomposition of the :class:`~.Select` gate. 
+* A new template :class:`~.Elbow` has been added. The Elbow operator is a three-qubit gate equivalent to an AND, or Toffoli, gate that leverages extra information
+  about the target wire to enable a more efficient decomposition. It is useful for an efficient decomposition of the :class:`~.Select` template, for example. 
   [(#7472)](https://github.com/PennyLaneAI/pennylane/pull/7472)
 
 * The transform `convert_to_mbqc_formalism` is added to the `ftqc` module to convert a circuit already

pennylane/templates/subroutines/elbow.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Xanadu Quantum Technologies Inc.
+# Copyright 2025 Xanadu Quantum Technologies Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -26,15 +26,15 @@
 class Elbow(Operation):
     r"""Elbow(wires)
 
-    The Elbow operator is a three-qubit gate analogous to an AND or Toffoli gate that leverages extra information
-    in the target wire to enable more efficient circuit decompositions: the ``Elbow`` assumes the target qubit
-    is initialized in :math:`|0\rangle`, while the ``Adjoint(Elbow)`` assumes the target output in :math:`|0\rangle`.
+    The Elbow operator is a three-qubit gate equivalent to an AND, or Toffoli, gate that leverages extra information
+    about the target wire to enable more efficient circuit decompositions: the ``Elbow`` assumes the target qubit
+    to be initialized in :math:`|0\rangle`, while the ``Adjoint(Elbow)`` assumes the target output to be :math:`|0\rangle`.
     For more details, see `Ryan Babbush et al.(2018), Fig 4 <https://arxiv.org/abs/1805.03662>`_.
 
     .. note::
 
         For correct usage of the operator, the user must ensure that the input or output is :math:`|0\rangle`
-        on the target wire when using ``Elbow`` or ``Adjoint(Elbow)`` respectively. Otherwise, the behavior could be
+        on the target wire when using ``Elbow`` or ``Adjoint(Elbow)``, respectively. Otherwise, the behavior could be
         different from the expected AND.
 
     **Details:**
@@ -108,14 +108,14 @@ def compute_matrix():  # pylint: disable=arguments-differ
         **Example**
 
         >>> print(qml.Elbow.compute_matrix())
-        [[1 0 0 0 0 0 0 0]
-         [0 -1j 0 0 0 0 0 0]
-         [0 0 1 0 0 0 0 0]
-         [0 0 0 -1j 0 0 0 0]
-         [0 0 0 0 1 0 0 0]
-         [0 0 0 0 0 1j 0 0]
-         [0 0 0 0 0 0 0 -1j]
-         [0 0 0 0 0 0 1 0]]
+        [[ 1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j -0.-1.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j -0.-1.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+1.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j -0.-1.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  0.+0.j  1.+0.j  0.+0.j]]
         """
 
         return qml.math.array(
@@ -132,9 +132,7 @@ def compute_matrix():  # pylint: disable=arguments-differ
         )
 
     @staticmethod
-    def compute_decomposition(
-        wires: WiresLike,
-    ):  # pylint: disable=arguments-differ
+    def compute_decomposition(wires: WiresLike):  # pylint: disable=arguments-differ
         r"""Representation of the operator as a product of other operators (static method).
 
         .. math:: O = O_1 O_2 \dots O_n.

tests/capture/test_templates.py

@@ -1190,9 +1190,7 @@ def qfunc():
     def test_elbow(self):
         """Test the primitive bind call of Elbow."""
 
-        kwargs = {
-            "wires": [0, 1, 2],
-        }
+        kwargs = {"wires": [0, 1, 2]}
 
         def qfunc():
             qml.Elbow(**kwargs)

tests/templates/test_subroutines/test_elbow.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024 Xanadu Quantum Technologies Inc.
+# Copyright 2025 Xanadu Quantum Technologies Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -28,9 +28,7 @@ class TestElbow:
     def test_standard_validity(self):
         """Check the operation using the assert_valid function."""
 
-        op = qml.Elbow(
-            wires=[0, 1, 2],
-        )
+        op = qml.Elbow(wires=[0, 1, 2])
         qml.ops.functions.assert_valid(op)
 
     def test_correctness(self):
@@ -78,7 +76,7 @@ def test_elbow_decompositions(self):
         for rule in qml.list_decomps(qml.Elbow):
             _test_decomposition_rule(qml.Elbow([0, 1, 2]), rule)
 
-    def test_matrix(self):
+    def test_compute_matrix(self):
 
         matrix = qml.Elbow([0, 1, 2]).compute_matrix()
         matrix_target = qml.math.array(