[TAPE] Adds circuit drawing functionality to the quantum tape

doc/code/qml_tape.rst

@@ -139,8 +139,6 @@ Tape mode provides several advantanges over the standard PennyLane QNode.
     In tape-mode, the QNode does not yet have feature-parity with the standard PennyLane
     QNode. Features currently not available in tape mode include:
 
-    * Circuit drawing and visualization
-
     * Metric tensor computation
 
     * The ability to automatically extract the layer structure of variational circuits
@@ -156,7 +154,6 @@ the internal structure of the QNode. When tape mode is enabled, the QNode is no
 responsible for recording quantum operations, executing devices, or computing gradients---these
 tasks have been delegated to an internal object that is created by the QNode, the **quantum tape**.
 
-
 In addition to being created internally by QNodes in tape mode, quantum tapes can also be created,
 nested, expanded (via :meth:`~.QuantumTape.expand`), and executed manually. Tape subclasses also provide
 additional gradient methods:

pennylane/beta/devices/default_tensor.py

@@ -31,7 +31,7 @@
     if int(v[0]) != 0 and int(v[1]) < 3:
         raise ImportError("default.tensor device requires TensorNetwork>=0.3")
 except ImportError as e:
-    raise ImportError("default.tensor device requires TensorNetwork>=0.3")
+    raise ImportError("default.tensor device requires TensorNetwork>=0.3") from e
 
 
 # tolerance for numerical errors

pennylane/circuit_drawer/representation_resolver.py

@@ -119,7 +119,7 @@ def single_parameter_representation(self, par):
         if isinstance(par, str):
             return par
 
-        return str(round(par, 3))
+        return f"{1.0 * par:.3g}"
 
     @staticmethod
     def _format_matrix_operation(operation, symbol, cache):
@@ -449,7 +449,10 @@ def element_representation(self, element, wire):
             return ""
         if isinstance(element, str):
             return element
-        if isinstance(element, qml.operation.Observable) and element.return_type is not None:
+        if (
+            isinstance(element, (qml.operation.Observable, qml.tape.MeasurementProcess))
+            and element.return_type is not None
+        ):
             return self.output_representation(element, wire)
 
         return self.operator_representation(element, wire)

pennylane/circuit_graph.py

@@ -548,7 +548,8 @@ def greedy_layers(self):
             operations[wire] = list(
                 filter(
                     lambda op: not (
-                        isinstance(op, qml.operation.Observable) and op.return_type is not None
+                        isinstance(op, (qml.operation.Observable, qml.tape.MeasurementProcess))
+                        and op.return_type is not None
                     ),
                     operations[wire],
                 )
@@ -576,7 +577,9 @@ def greedy_layers(self):
         for wire in sorted(self._grid):
             observables[wire] = list(
                 filter(
-                    lambda op: isinstance(op, qml.operation.Observable)
+                    lambda op: isinstance(
+                        op, (qml.operation.Observable, qml.tape.MeasurementProcess)
+                    )
                     and op.return_type is not None,
                     self._grid[wire],
                 )

pennylane/tape/circuit_graph.py

@@ -17,6 +17,7 @@
 """
 import networkx as nx
 
+import pennylane as qml
 from pennylane import CircuitGraph
 
 
@@ -29,6 +30,12 @@ class TapeCircuitGraph(CircuitGraph):
     def __init__(self, ops, obs, wires):
         self._operations = ops
         self._observables = obs
+
+        for m in self._observables:
+            if m.return_type is qml.operation.State:
+                # state measurements are applied to all device wires
+                m._wires = wires  # pylint: disable=protected-access
+
         super().__init__(ops + obs, variable_deps={}, wires=wires)
 
     @property

pennylane/tape/qnode.py

@@ -459,6 +459,51 @@ def __call__(self, *args, **kwargs):
 
         return __import__(res_type_namespace).squeeze(res)
 
+    def draw(self, charset="unicode"):
+        """Draw the quantum tape as a circuit diagram.
+
+        Consider the following circuit as an example:
+
+        .. code-block:: python3
+
+            @qml.qnode(dev)
+            def circuit(a, w):
+                qml.Hadamard(0)
+                qml.CRX(a, wires=[0, 1])
+                qml.Rot(*w, wires=[1])
+                qml.CRX(-a, wires=[0, 1])
+                return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        We can draw the QNode after execution:
+
+        >>> result = circuit(2.3, [1.2, 3.2, 0.7])
+        >>> print(circuit.draw())
+        0: ──H──╭C────────────────────────────╭C─────────╭┤ ⟨Z ⊗ Z⟩
+        1: ─────╰RX(2.3)──Rot(1.2, 3.2, 0.7)──╰RX(-2.3)──╰┤ ⟨Z ⊗ Z⟩
+        >>> print(circuit.draw(charset="ascii"))
+        0: --H--+C----------------------------+C---------+| <Z @ Z>
+        1: -----+RX(2.3)--Rot(1.2, 3.2, 0.7)--+RX(-2.3)--+| <Z @ Z>
+
+        Args:
+            charset (str, optional): The charset that should be used. Currently, "unicode" and
+                "ascii" are supported.
+
+        Raises:
+            ValueError: if the given charset is not supported
+            .QuantumFunctionError: drawing is impossible because the underlying
+                quantum tape has not yet been constructed
+
+        Returns:
+            str: the circuit representation of the tape
+
+        """
+        if self.qtape is None:
+            raise qml.QuantumFunctionError(
+                "The QNode can only be drawn after its quantum tape has been constructed."
+            )
+
+        return self.qtape.draw(charset=charset)
+
     def to_tf(self, dtype=None):
         """Apply the TensorFlow interface to the internal quantum tape.
 
@@ -467,7 +512,7 @@ def to_tf(self, dtype=None):
                 output. If not provided, the default is ``tf.float64``.
 
         Raises:
-            qml.QuantumFunctionError: if TensorFlow >= 2.1 is not installed
+            .QuantumFunctionError: if TensorFlow >= 2.1 is not installed
         """
         # pylint: disable=import-outside-toplevel
         try:
@@ -484,11 +529,11 @@ def to_tf(self, dtype=None):
             if self.qtape is not None:
                 TFInterface.apply(self.qtape, dtype=tf.as_dtype(self.dtype))
 
-        except ImportError:
+        except ImportError as e:
             raise qml.QuantumFunctionError(
                 "TensorFlow not found. Please install the latest "
                 "version of TensorFlow to enable the 'tf' interface."
-            )
+            ) from e
 
     def to_torch(self, dtype=None):
         """Apply the Torch interface to the internal quantum tape.
@@ -498,7 +543,7 @@ def to_torch(self, dtype=None):
                 output. If not provided, the default is ``torch.float64``.
 
         Raises:
-            qml.QuantumFunctionError: if PyTorch >= 1.3 is not installed
+            .QuantumFunctionError: if PyTorch >= 1.3 is not installed
         """
         # pylint: disable=import-outside-toplevel
         try:
@@ -518,11 +563,11 @@ def to_torch(self, dtype=None):
             if self.qtape is not None:
                 TorchInterface.apply(self.qtape, dtype=self.dtype)
 
-        except ImportError:
+        except ImportError as e:
             raise qml.QuantumFunctionError(
                 "PyTorch not found. Please install the latest "
                 "version of PyTorch to enable the 'torch' interface."
-            )
+            ) from e
 
     def to_autograd(self):
         """Apply the Autograd interface to the internal quantum tape."""

pennylane/tape/tapes/tape.py

@@ -812,6 +812,41 @@ def graph(self):
 
         return self._graph
 
+    def draw(self, charset="unicode"):
+        """Draw the quantum tape as a circuit diagram.
+
+        Consider the following circuit as an example:
+
+        .. code-block:: python3
+
+            with QuantumTape() as tape:
+                qml.Hadamard(0)
+                qml.CRX(2.3, wires=[0, 1])
+                qml.Rot(1.2, 3.2, 0.7, wires=[1])
+                qml.CRX(-2.3, wires=[0, 1])
+                qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        We can draw the tape after construction:
+
+        >>> print(tape.draw())
+        0: ──H──╭C────────────────────────────╭C─────────╭┤ ⟨Z ⊗ Z⟩
+        1: ─────╰RX(2.3)──Rot(1.2, 3.2, 0.7)──╰RX(-2.3)──╰┤ ⟨Z ⊗ Z⟩
+        >>> print(tape.draw(charset="ascii"))
+        0: --H--+C----------------------------+C---------+| <Z @ Z>
+        1: -----+RX(2.3)--Rot(1.2, 3.2, 0.7)--+RX(-2.3)--+| <Z @ Z>
+
+        Args:
+            charset (str, optional): The charset that should be used. Currently, "unicode" and
+                "ascii" are supported.
+
+        Raises:
+            ValueError: if the given charset is not supported
+
+        Returns:
+            str: the circuit representation of the tape
+        """
+        return self.graph.draw(charset=charset, show_variable_names=False)
+
     @property
     def data(self):
         """Alias to :meth:`~.get_parameters` and :meth:`~.set_parameters`

pennylane/wires.py

@@ -242,11 +242,11 @@ def map(self, wire_map):
 
         try:
             new_wires = Wires(new_wires)
-        except WireError:
+        except WireError as e:
             raise WireError(
                 "Failed to implement wire map {}. Make sure that the new labels are unique and "
                 "valid wire labels.".format(w, wire_map)
-            )
+            ) from e
 
         return new_wires
 

tests/circuit_drawer/test_representation_resolver.py

@@ -74,7 +74,7 @@ def test_index_of_array_or_append(self, list, element, index, list_after):
         assert RepresentationResolver.index_of_array_or_append(element, list) == index
         assert list == list_after
 
-    @pytest.mark.parametrize("par,expected", [(3, "3"), (5.236422, "5.236"),])
+    @pytest.mark.parametrize("par,expected", [(3, "3"), (5.236422, "5.24"),])
     def test_single_parameter_representation(self, unicode_representation_resolver, par, expected):
         """Test that single parameters are properly resolved."""
         assert unicode_representation_resolver.single_parameter_representation(par) == expected
@@ -95,7 +95,7 @@ def test_single_parameter_representation_kwarg_variable(
             unicode_representation_resolver.single_parameter_representation(kwarg_variable) == "1"
         )
 
-    @pytest.mark.parametrize("par,expected", [(3, "3"), (5.236422, "5.236"),])
+    @pytest.mark.parametrize("par,expected", [(3, "3"), (5.236422, "5.24"),])
     def test_single_parameter_representation_varnames(
         self, unicode_representation_resolver_varnames, par, expected
     ):