Add custom drawing for TemporaryAND elbows (#8017)

**Context:**
We added elbow gates `qml.TemporaryAND`, which are drawn like any
generic multi-qubit gate.

**Description of the Change:**
Add custom drawing.
Also add the control values of `TemporaryAND` to its `repr`.

Open questions:
- [x] Should we remove zeroed wires more prominently (more complicated
to implement)? i.e., do we prefer
```python
0: ─╭●──┤  <Z>
1: ─├●──┤     
2: ─╰───┤     
a: ──●╮─┤     
b: ──●┤─┤     
c: ───╯─┤ 
```
or 
```python
0: ─╭●──┤  <Z>
1: ─├●──┤     
2:  ╰───┤     
a: ──●╮─┤     
b: ──●┤─┤     
c: ───╯ ┤ 
```
?

**edit:** There seems to be agreement that not skipping wires is fine.

- [x] Should the control nodes of left and right elbows align, at the
expense of slightly larger drawing depth? I.e., do we prefer
```python
0: ─╭●──┤  <Z>
1: ─├●──┤     
2: ─╰───┤     
a: ──●╮─┤     
b: ──●┤─┤     
c: ───╯─┤ 
```
or 
```python
0: ─╭●─┤  <Z>
1: ─├●─┤     
2: ─╰──┤     
a: ─●╮─┤     
b: ─●┤─┤     
c: ──╯─┤ 
```
?
There seems to be agreement that aligning the control nodes is nicer.

**Benefits:**
much nicer and easier to debug circuit diagrams.
Example:
```python
import pennylane as qml
from pennylane.templates.subroutines.select import _select_decomp_partial_unary
from functools import partial 
ops = [qml.X(0), qml.Y(1), qml.SWAP([0, 1]), qml.RX(0.7, 2), qml.IsingZZ(0.4, [0, 2]), qml. RX(0.7, 1)]
control = ["c0", "c1", "c2"]
work = ["aux0", "aux1"]

@partial(qml.draw, wire_order=["c0", "c1", "aux0", "c2", "aux1"] + [0, 1, 2])
@qml.qnode(qml.device("default.qubit"))
def node():
    _select_decomp_partial_unary(ops, control, work)
    return qml.expval(qml.Z(0))

print(node())
```
Before:
```python
  c0: ─╭TemporaryAND──X────────────────────────────────────╭●──X────────────────────────────── ···
  c1: ─├TemporaryAND───────────────────────────────────────│────────────────────────────────── ···
aux0: ─╰TemporaryAND─╭TemporaryAND────╭●────╭TemporaryAND†─╰X─╭TemporaryAND───────╭●────────── ···
  c2: ───────────────├TemporaryAND────│─────├TemporaryAND†────├TemporaryAND───────│─────────── ···
aux1: ───────────────╰TemporaryAND─╭●─╰X─╭●─╰TemporaryAND†────╰TemporaryAND─╭●────╰X─╭●─────── ···
   0: ─────────────────────────────╰X────│──────────────────────────────────├SWAP────│──────── ···
   1: ───────────────────────────────────╰Y─────────────────────────────────╰SWAP────│──────── ···
   2: ───────────────────────────────────────────────────────────────────────────────╰RX(0.70) ···

  c0: ··· ────────────────╭TemporaryAND†─╭TemporaryAND────────────────╭●────────── ···
  c1: ··· ────────────────├TemporaryAND†─│────────────────────────────│─────────── ···
aux0: ··· ─╭TemporaryAND†─╰TemporaryAND†─│────────────────────────────│─────────── ···
  c2: ··· ─├TemporaryAND†────────────────├TemporaryAND────────────────│─────────── ···
aux1: ··· ─╰TemporaryAND†────────────────╰TemporaryAND─╭●─────────────╰X─╭●─────── ···
   0: ··· ─────────────────────────────────────────────├IsingZZ(0.40)────│──────── ···
   1: ··· ─────────────────────────────────────────────│─────────────────╰RX(0.70) ···
   2: ··· ─────────────────────────────────────────────╰IsingZZ(0.40)───────────── ···

  c0: ··· ─╭TemporaryAND†─┤     
  c1: ··· ─│──────────────┤     
aux0: ··· ─│──────────────┤     
  c2: ··· ─├TemporaryAND†─┤     
aux1: ··· ─╰TemporaryAND†─┤     
   0: ··· ────────────────┤  <Z>
   1: ··· ────────────────┤     
   2: ··· ────────────────┤ 
```

After:
```python
  c0: ─╭○──X──────────────╭●──X─────────────────────────○╮─╭●────────────────╭●────────────●╮─┤     
  c1: ─├○─────────────────│─────────────────────────────●┤─│─────────────────│──────────────│─┤     
aux0: ─╰──╭●────╭●─────●╮─╰X─╭●───────╭●────────────●╮───╯─│─────────────────│──────────────│─┤     
  c2: ────├○────│──────●┤────├○───────│─────────────●┤─────├○────────────────│─────────────●┤─┤     
aux1: ────╰──╭●─╰X─╭●───╯────╰──╭●────╰X─╭●──────────╯─────╰──╭●─────────────╰X─╭●──────────╯─┤     
   0: ───────╰X────│────────────├SWAP────│────────────────────├IsingZZ(0.40)────│─────────────┤  <Z>
   1: ─────────────╰Y───────────╰SWAP────│────────────────────│─────────────────╰RX(0.70)─────┤     
   2: ───────────────────────────────────╰RX(0.70)────────────╰IsingZZ(0.40)──────────────────┤     
```

**Possible Drawbacks:**
N/A

**Related GitHub Issues:**

---------

Co-authored-by: ANT0N <[email protected]>
Co-authored-by: Isaac De Vlugt <[email protected]>

Author: 3 people

doc/releases/changelog-dev.md

@@ -64,6 +64,30 @@
 
 <h3>Improvements 🛠</h3>
 
+* The printing and drawing of :class:`~.TemporaryAND`, also known as ``qml.Elbow``, and its adjoint
+  have been improved to be more legible and consistent with how it's depicted in circuits in the literature.
+  [(#8017)](https://github.com/PennyLaneAI/pennylane/pull/8017)
+
+  ```python
+  import pennylane as qml
+
+  @qml.draw
+  @qml.qnode(qml.device("lightning.qubit", wires=4))
+  def node():
+      qml.TemporaryAND([0, 1, 2], control_values=[1, 0])
+      qml.CNOT([2, 3])
+      qml.adjoint(qml.TemporaryAND([0, 1, 2], control_values=[1, 0]))
+      return qml.expval(qml.Z(3))
+  ```
+
+  ```pycon
+  print(node())
+  0: ─╭●─────●╮─┤     
+  1: ─├○─────○┤─┤     
+  2: ─╰──╭●───╯─┤     
+  3: ────╰X─────┤  <Z>
+  ```
+
 * Several templates now have decompositions that can be accessed within the graph-based
   decomposition system (:func:`~.decomposition.enable_graph`), allowing workflows
   that include these templates to be decomposed in a resource-efficient and performant

pennylane/drawer/_add_obj.py

@@ -42,8 +42,9 @@
     VarianceMP,
 )
 from pennylane.operation import Operator
-from pennylane.ops import Conditional, Controlled, GlobalPhase, Identity
+from pennylane.ops import Adjoint, Conditional, Controlled, GlobalPhase, Identity
 from pennylane.tape import QuantumScript
+from pennylane.templates.subroutines import TemporaryAND
 
 
 def _add_cond_grouping_symbols(op, layer_str, config):
@@ -77,7 +78,7 @@ def _add_cond_grouping_symbols(op, layer_str, config):
     return layer_str
 
 
-def _add_grouping_symbols(op_wires, layer_str, config):
+def _add_grouping_symbols(op_wires, layer_str, config, closing=False):
     """Adds symbols indicating the extent of a given sequence of wires.
     Does nothing if the sequence has length 0 or 1."""
 
@@ -87,11 +88,18 @@ def _add_grouping_symbols(op_wires, layer_str, config):
     mapped_wires = [config.wire_map[w] for w in op_wires]
     min_w, max_w = min(mapped_wires), max(mapped_wires)
 
-    layer_str[min_w] = "╭"
-    layer_str[max_w] = "╰"
+    if closing:
+        layer_str[min_w] += "╮"
+        layer_str[max_w] += "╯"
 
-    for w in range(min_w + 1, max_w):
-        layer_str[w] = "├" if w in mapped_wires else "│"
+        for w in range(min_w + 1, max_w):
+            layer_str[w] += "┤" if w in mapped_wires else "│"
+    else:
+        layer_str[min_w] = "╭"
+        layer_str[max_w] = "╰"
+
+        for w in range(min_w + 1, max_w):
+            layer_str[w] = "├" if w in mapped_wires else "│"
 
     return layer_str
 
@@ -159,6 +167,47 @@ def _add_controlled_global_op(obj, layer_str, config):
     return layer_str
 
 
+def _add_elbow_core(obj, layer_str, config):
+    cvals = obj.hyperparameters["control_values"]
+    mapped_wires = [config.wire_map[w] for w in obj.wires]
+    layer_str[mapped_wires[0]] += "●" if cvals[0] else "○"
+    layer_str[mapped_wires[1]] += "●" if cvals[1] else "○"
+    layer_str[mapped_wires[2]] += "─"
+    return layer_str, mapped_wires
+
+
+@_add_obj.register
+def _add_left_elbow(
+    obj: TemporaryAND, layer_str, config, tape_cache=None, skip_grouping_symbols=False
+):
+    """Updates ``layer_str`` with ``op`` operation of type ``TemporaryAND``,
+    also known as left elbow."""
+    layer_str = _add_grouping_symbols(obj.wires, layer_str, config)
+    layer_str, _ = _add_elbow_core(obj, layer_str, config)
+    return layer_str
+
+
+def _add_right_elbow(obj: TemporaryAND, layer_str, config):
+    """Updates ``layer_str`` with ``op`` operation of type ``Adjoint(TemporaryAND)``,
+    also known as right elbow."""
+    layer_str, mapped_wires = _add_elbow_core(obj, layer_str, config)
+    # Fill with "─" on intermediate wires the elbow does not act on, to shift "|" correctly
+    for w in range(min(mapped_wires) + 1, max(mapped_wires)):
+        if w not in mapped_wires:
+            layer_str[w] += "─"
+    return _add_grouping_symbols(obj.wires, layer_str, config, closing=True)
+
+
+@_add_obj.register
+def _add_adjoint(obj: Adjoint, layer_str, config, tape_cache=None, skip_grouping_symbols=False):
+    """Updates ``layer_str`` with ``op`` operation of type Adjoint. Currently
+    only differs from ``_add_op`` if the base of the adjoint op is a ``TemporaryAND``,
+    making the overall object a right elbow."""
+    if isinstance(obj.base, TemporaryAND):
+        return _add_right_elbow(obj.base, layer_str, config)
+    return _add_op(obj, layer_str, config, tape_cache, skip_grouping_symbols)
+
+
 @_add_obj.register
 def _add_op(obj: Operator, layer_str, config, tape_cache=None, skip_grouping_symbols=False):
     """Updates ``layer_str`` with ``op`` operation."""

pennylane/templates/subroutines/temporary_and.py

@@ -74,6 +74,11 @@ def circuit():
 
     .. code-block:: pycon
 
+        >>> print(qml.draw(circuit)())
+        0: ──X─╭●─────●╮─┤ ╭Sample
+        1: ──X─├●─────●┤─┤ ├Sample
+        2: ────╰──╭●───╯─┤ ├Sample
+        3: ───────╰X─────┤ ╰Sample
         >>> print(circuit())
         [1 1 0 1]
     """
@@ -89,6 +94,12 @@ def circuit():
 
     resource_keys = set()
 
+    def __repr__(self):
+        cvals = self.hyperparameters["control_values"]
+        if all(cvals):
+            return f"TemporaryAND(wires={self.wires})"
+        return f"TemporaryAND(wires={self.wires}, control_values={cvals})"
+
     def __init__(self, wires: WiresLike, control_values=(1, 1), id=None):
         wires = Wires(wires)
         self.hyperparameters["control_values"] = tuple(control_values)

tests/drawer/test_tape_text.py

@@ -294,6 +294,8 @@ def test_add_measurements_cache(self):
             (qml.Snapshot(), ["─|Snap|", "─|Snap|", "─|Snap|", "─|Snap|"]),
             (qml.Barrier(), ["─||", "─||", "─||", "─||"]),
             (qml.S(0) @ qml.T(0), ["─S@T", "─", "─", "─"]),
+            (qml.TemporaryAND([0, 1, 3]), ["╭●", "├●", "│", "╰─"]),
+            (qml.TemporaryAND([1, 0, 3], control_values=(0, 1)), ["╭●", "├○", "│", "╰─"]),
         ],
     )
     def test_add_obj(self, op, out):
@@ -675,6 +677,14 @@ def test_setting_max_length(self, ml):
         ),
         "0: ─╭○─┤  \n1: ─├●─┤  \n2: ─├○─┤  \n3: ─├●─┤  \n4: ─╰Y─┤  ",
     ),
+    (
+        qml.TemporaryAND([3, 0, 2], control_values=(1, 0)),
+        "3: ─╭●─┤  \n0: ─├○─┤  \n2: ─╰──┤  ",
+    ),
+    (
+        qml.adjoint(qml.TemporaryAND([3, 0, 2], control_values=(0, 1))),
+        "3: ──○╮─┤  \n0: ──●┤─┤  \n2: ───╯─┤  ",
+    ),
 ]
 
 
@@ -727,6 +737,31 @@ def test_blocking_multiwire_gate(self):
 
         assert tape_text(_tape, wire_order=[0, 1, 2]) == expected
 
+    def test_multiple_elbows(self):
+        """Test that multiple elbows are drawn correctly."""
+        _tape = qml.tape.QuantumScript(
+            [
+                qml.TemporaryAND(["a", "b", "c"]),
+                qml.adjoint(qml.TemporaryAND(["f", "d", "e"])),
+                qml.adjoint(qml.TemporaryAND(["a", "d", "b"], control_values=(0, 0))),
+                qml.TemporaryAND(["e", "h", "f"], control_values=(0, 1)),
+            ]
+        )
+        expected = (
+            "a: ─╭●───○╮─┤  \n"
+            "b: ─├●────┤─┤  \n"
+            "c: ─╰─────│─┤  \n"
+            "d: ──●╮──○╯─┤  \n"
+            "e: ───┤─╭○──┤  \n"
+            "f: ──●╯─├───┤  \n"
+            "g: ─────│───┤  \n"
+            "h: ─────╰●──┤  "
+        )
+        out = tape_text(
+            _tape, wire_order=["a", "b", "c", "d", "e", "f", "g", "h"], show_all_wires=True
+        )
+        assert out == expected
+
 
 tape_matrices = qml.tape.QuantumScript(
     ops=[qml.StatePrep([1.0, 0.0, 0.0, 0.0], wires=(0, 1)), qml.QubitUnitary(np.eye(2), wires=0)],

tests/templates/test_subroutines/test_temporary_and.py

@@ -24,6 +24,14 @@
 class TestTemporaryAND:
     """Tests specific to the TemporaryAND operation"""
 
+    def test_repr(self):
+        """Test the repr of TemporaryAND."""
+        assert repr(qml.TemporaryAND(wires=[0, "a", 2])) == "TemporaryAND(wires=Wires([0, 'a', 2]))"
+        assert (
+            repr(qml.TemporaryAND(wires=[0, "a", 2], control_values=(0, 1)))
+            == "TemporaryAND(wires=Wires([0, 'a', 2]), control_values=(0, 1))"
+        )
+
     def test_alias(self):
         """Test that Elbow is an alias of TemporaryAND"""
         op1 = qml.TemporaryAND(wires=[0, "a", 2], control_values=(0, 0))